矩阵树定理--luoguP4208 [JSOI2008]最小生成树计数

以前用 $dfs$ 做的，用基尔霍夫矩阵真的玄啊

首先这道题有这么几个定理：（来自Z-Y-Y-S的博客）
定理一：如果 $A, B$ 同为 $G$ 的最小生成树，且 $A$ 的边权从小到大为 $w(a_1), w(a_2), w(a_3), \cdots w(a_n)$ ， $B$ 的边权从小到大为 $w(b_1), w(b_2), w(b_3), \cdots w(b_n)$ ，则有 $w(a_i) = w(b_i)$ 。
证明：设 $A, B$ 第一个不同的边的下标为 $i$ ，不妨设 $w(a_i) \le w(b_i)$ ，如果不存在这样的 $i$ ，无需证明。
情况一： $a_i$ 在 $B$ 中，为 $b_j$ 。那么显然有 $j>i$ （否则 $i$ 不是第一个不同的边），则有 $w(a_i)\le w(b_i) \le w(b_j) = w(a_i)$ ，所以有 $w(a_i) = w(b_i) = w(b_j)$ ，所以可以调换 $b_i, b_j$ 的位置， $B$ 的权值排列不会改变， $A$ 与 $B$ 这样前 $i$ 条边均为相等，可以递归下去证明。
情况二： $a_i$ 不在 $B$ 中。考虑将 $a_i$ 加入 $B$ ，则形成了一个环，环中的权值 $v\le w(a_i)$ （否则 $B$ 不是最小生成树），且一定有一条边 $b_j$ 不在 $B$ 中，此时仍有 $j>i$ （否则 $i$ 不是第一个不同的边），所以有 $w(a_i)\le w(b_i) \le w(b_j) \le w(a_i)$ ，所以仍有 $w(a_i) = w(b_i) = w(b_j)$ ，可以将 $b_j$ 替换为 $a_i$ ， $B$ 的权值排列不会改变且仍为最小生成树，仍然调换 $b_i, b_j$ 的位置， $B$ 的权值排列仍会改变，这样 $A$ 与 $B$ 前 $i$ 条边均为相等，可以递归下去证明。这样换边不会有问题，因为 Kruskal 算法中唯一的状态就是连通性，我们没有改变其连通性，所以是可以递归证明的。

定理二：如果 $A, B$ 同为 $G$ 的最小生成树，如果 $A, B$ 都从零开始从小到大加边（ $A$ 加 $A$ 的边， $B$ 加 $B$ 的边）的话，每种权值加完后图的联通性相同。
证明：归纳法证明，没有边时显然成立，假设对于权值小于 $v$ 的成立。考虑权值为 $v$ 的边，如果连通性不相同，必然存在 $u, v$ 两点间连通性不同，假设 $A$ 中 $u, v$ 联通，根据 $A, B$ 所有小于 $v$ 的边连通性相同，所以必然存在一条 $u\rightarrow v$ 权值为 $v$ 的边，而根据 Kruskal 算法的执行过程， $B$ 不可能不加这条边，所以两棵最小生成树 $A, B$ 各自权值小于等于 $v$ 的边仍然满足连通性相同。由归纳法可知定理二成立。

定理三：如果在最小生成树 $A$ 中权值为 $v$ 的边有 $k$ 条，用任意 $k$ 条权值为 $v$ 的边替换 $A$ 中的权为 $v$ 的边且不产生环的方案都是一棵合法最小生成树。
证明：根据之前的定理，其余的边造成的连通性是定的，权值和也是定的，那么选 $k$ 条不产生环一定能形成一棵树，而且权值与最小生成树的权值一样，故也是最小生成树。

有了这些定理，就可以基尔霍夫矩阵来算方案，每次乘起来，但算的时候要先“缩点”，其实就是排个序去重之类的，然后算完方案随便找一种连起来，但注意算方案的时候有可能不能构成生成树，还需要先把图再连一下使它能有生成树。

细节很多，写的时候一定要脑子清楚
代码如下：（改动比较多，有点丑）

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#define N 105
#define M 1005
#define LL long long
#define int LL
using namespace std;

inline int rd(){
    int x=0,f=1;char c=' ';
    while(c<'0' || c>'9') f=c=='-'?-1:1,c=getchar();
    while(c<='9' && c>='0') x=x*10+c-'0',c=getchar();
    return x*f;
}

int n,m,a[N][N],fa[N],fa2[N],ans=1,c[N<<1],sum;
const int mod=31011;

struct EDGE{
    int fr,to,w;
    bool operator <(const EDGE &x) const{
        return w<x.w;
    }
}edge[M],tmp[M];

inline int Matrix_tree(int tot){
    for(int i=1;i<tot;i++)
        for(int j=1;j<tot;j++)
            a[i][j]=(a[i][j]+mod)%mod;
    int ans=1,f=1;
    for(int i=1;i<tot;i++){
        for(int j=i+1;j<tot;j++){
            if(!a[j][i]) continue;
            int A=a[i][i],B=a[j][i];
            while(B){
                int t=A/B;
                A%=B; swap(A,B);
                for(int k=i;k<tot;k++) a[i][k]=(a[i][k]-1LL*t*a[j][k]+mod)%mod;
                for(int k=i;k<tot;k++) swap(a[i][k],a[j][k]); f=-f;
            }
        }
        if(!a[i][i]) return 0;
        ans=1LL*ans*a[i][i]%mod;
    }
    if(f==-1) ans=mod-ans%mod;
    return (ans+mod)%mod;
}

inline int find(int x){
    if(x==fa[x]) return x;
    return fa[x]=find(fa[x]);
}
inline int find2(int x){
    if(x==fa2[x]) return x;
    return fa2[x]=find2(fa2[x]);
}

inline int solve(int l,int r){
    int cnt=0,num=0;
    for(int i=l;i<=r;i++){
        int x=find(edge[i].fr),y=find(edge[i].to);
        tmp[i].fr=x,tmp[i].to=y;
        if(x!=y)
            c[++num]=x,c[++num]=y;
    }
    sort(c+1,c+num+1); num=unique(c+1,c+num+1)-c-1;
    for(int i=1;i<=num;i++) fa2[i]=i;
    for(int i=l;i<=r;i++){
        if(tmp[i].fr==tmp[i].to) continue;
        int u=find(tmp[i].fr),v=find(tmp[i].to);
        if(u!=v) sum--,fa[u]=v;
        u=lower_bound(c+1,c+num+1,tmp[i].fr)-c; v=lower_bound(c+1,c+num+1,tmp[i].to)-c;
        a[u][u]++,a[u][v]--,a[v][v]++,a[v][u]--;
        int x=find2(u),y=find2(v);
        if(x!=y) fa2[x]=y;
    } 
    for(int i=2;i<=num;i++)
        if(find2(i)!=find2(i-1)){
            int u=find2(i),v=find2(i-1);
            a[u][u]++,a[u][v]--,a[v][v]++,a[v][u]--;
            fa2[u]=v;
        }
    ans=1LL*ans*Matrix_tree(num)%mod;
}

signed main(){
    n=rd(); m=rd();
    for(int i=1;i<=m;i++) edge[i].fr=rd(),edge[i].to=rd(),edge[i].w=rd();
    sort(edge+1,edge+m+1); int u,v; sum=n;
    for(int i=1;i<=n;i++) fa[i]=i;
    for(int i=1;i<=m;){
        int j=i; while(edge[j].w==edge[i].w) j++; j--;
        if(i==j){
            u=find(edge[i].fr),v=find(edge[i].to);
            if(u!=v) fa[u]=v,sum--;
        }
        else{
            memset(a,0,sizeof a); solve(i,j);
        }
        i=j+1;
    }
    if(sum>1) puts("0");
    else printf("%lld\n",ans);
    return 0;
}

矩阵树定理--luoguP4208 [JSOI2008]最小生成树计数

猜你喜欢