[JSOI2008]最小生成树计数

题意

最小生成树计数

---

题解

考虑最小生成树的两个性质：

$1.$不同的最小生成树中,每种权值的边出现的个数是确定的

$2.$不同的生成树中,某一种权值的边连接完成后,形成的联通块状态是一样的

所以我们可以把边权相同的边放在一起处理

举个例子(图片是网上下的)

其中虚线边表示边权相同的边

假设其中每个联通块内的答案已经算完了,考虑缩点

那么我们用矩阵树定理可以算出上图的生成树的个数

所以我们只要在$Kruskal$中处理完一种边权的边后做一遍当前这些联通块的生成树计数就好了

然后根据乘法原理把每一种边权的答案乘就好了

具体怎么处理联通块

我们用$belong$表示合并之前的这个点所属的联通块(即$s_1,s_2,s_3$),$fa$表示连了当前这种长的边后这个点所属的联通块(整个一坨)

对于一个整的联通块$fa$,我们记录其中当前所有长度的边$(u,v)$

缩点之后就是$(belong_u,belong_v)$,也就是只要求当前的$belong$形成的基尔霍夫矩阵的值就好了

因为这题的模数不是质数所以要用到辗转相除来解行列式

#include<bits/stdc++.h>
#define fp(i,a,b) for(register int i=a,I=b+1;i<I;++i)
#define fd(i,a,b) for(register int i=a,I=b-1;i>I;--i)
#define go(u) for(register int i=fi[u],v=e[i].to;i;v=e[i=e[i].nx].to)
#define file(s) freopen(s".in","r",stdin),freopen(s".out","w",stdout)
template<class T>inline bool cmax(T&a,const T&b){return a<b?a=b,1:0;}
template<class T>inline bool cmin(T&a,const T&b){return a>b?a=b,1:0;}
using namespace std;
const int N=105,M=1005,P=31011;
typedef int arr[N];
struct eg{int u,v,w;}e[M];
int n,m,ans=1;arr fa,bl,vis,g[N],G[N];vector<int>s[N];
int gf(int u,int*fa){return fa[u]==u?u:fa[u]=gf(fa[u],fa);}
inline int pls(int a,int b){return a+=b,a>=P?a-P:a;}
inline int sub(int a,int b){return a-=b,a<0?a+P:a;}
inline int det(int n){
    int a,b,t,f=1,tp=1;
    fp(i,1,n)fp(j,1,n)G[i][j]=pls(P,G[i][j]);
    fp(i,1,n){
        fp(j,i+1,n){
            a=G[i][i],b=G[j][i];
            while(b){
                t=a/b;a%=b;swap(a,b);
                fp(k,i,n)G[i][k]=sub(G[i][k],t*G[j][k]%P);
                fp(k,i,n)swap(G[i][k],G[j][k]);f=-f;
            }
        }
        if(!G[i][i])return 0;
        tp=tp*G[i][i]%P;
    }
    return pls(P,f*tp);
}
inline void calc(){
    fp(i,1,n)if(vis[i]){s[gf(i,fa)].push_back(i);vis[i]=0;}
    fp(i,1,n)if(s[i].size()>1){
        int t=s[i].size(),*a=s[i].data();
        memset(G,0,sizeof G);
        fp(j,1,t)fp(k,j+1,t){
            int u=a[j-1],v=a[k-1];
            if(g[u][v]){
                G[j][k]=G[k][j]=-g[u][v];
                G[j][j]+=g[u][v],G[k][k]+=g[u][v];
            }
        }
        ans=ans*det(t-1)%P;
        fp(j,1,t)bl[a[j-1]]=i;
    }
    fp(i,1,n)s[i].clear(),fa[i]=bl[i]=gf(i,bl);
}
inline bool cmp(const eg&a,const eg&b){return a.w<b.w;}
int main(){
    #ifndef ONLINE_JUDGE
        file("s");
    #endif
    scanf("%d%d",&n,&m);
    fp(i,1,n)fa[i]=bl[i]=i;
    fp(i,1,m)scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].w);
    sort(e+1,e+m+1,cmp);e[0]=e[1];
    fp(i,1,m){
        if(e[i].w^e[i-1].w)calc();
        int u=gf(e[i].u,bl),v=gf(e[i].v,bl);
        if(u^v){
            vis[u]=vis[v]=1;
            ++g[u][v],++g[v][u];
            fa[gf(u,fa)]=gf(v,fa);
        }
    }calc();
    fp(i,2,n)if(bl[i]^bl[i-1])return puts("0"),0;
    printf("%d",ans);
return 0;
}