最小生成树计数 模板 hdu 4408

题意是给定n个点，m条边的无向图，求最小生成树的个数对p取模。

用kruscal计算最小生成树时，每次取连接了两个不同联通块的最小的边。也就是先处理d₁条c₁长度的边，再处理d₂条c₂长度的边。长度相同的边无论怎么选，最大联通情况都是固定的。 分别对c_i长度的边产生的几个联通块计算生成树数量再乘起来，然后把这些联通块缩点，再计算c_i+1长度的边。

生成树计数用Matrix-Tree定理，上一篇是无重边的，这题的缩点后是会产生重边的，Matrix-tree也适用：   //抄别人博客的

Kirchhoff矩阵任意n-1阶子矩阵的行列式的绝对值就是无向图的生成树的数量。

Kirchhoff矩阵的定义是度数矩阵-邻接矩阵。

1、G的度数矩阵D[G]：n*n的矩阵，D_ii等于V_i的度数，其余为0。
2、G的邻接矩阵A[G]：n*n的矩阵， V_i、V_j之间有边直接相连，则 A_ij=ij之间的边数，否则为0。

并查集fa[i]是当前长度之前，节点所属的联通块，ka[i]是当前长度的边连接后它在的联通块。

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <vector>
 using namespace std;
 typedef long long ll;
 const int N=;
 const int M=;
 ll n,m,p,ans;
 vector<int>gra[N];
 struct edge{
     int u,v,w;
 }e[M];
 int cmp(edge a,edge b){
     return a.w<b.w;
 }
 ll mat[N][N],g[N][N];
 ll fa[N],ka[N],vis[N];
 ll det(ll c[][N],ll n){
     ll i,j,k,t,ret=;
     for(i=;i<n;i++)
     for(j=;j<n;j++) c[i][j]%=p;
     for(i=; i<n; i++){
         for(j=i+; j<n; j++)
             while(c[j][i]){
                 t=c[i][i]/c[j][i];
                 for(k=i; k<n; k++)
                     c[i][k]=(c[i][k]-c[j][k]*t)%p;
                 swap(c[i],c[j]);
                 ret=-ret;
             }
         if(c[i][i]==)
             return 0L;
         ret=ret*c[i][i]%p;
     }
     return (ret+p)%p;
 }
 ll find(ll a,ll f[]){
     return f[a]==a?a:find(f[a],f);
 }
 void matrix_tree(){//对当前长度的边连接的每个联通块计算生成树个数
     for(int i=;i<n;i++)if(vis[i]){//当前长度的边连接了i节点
         gra[find(i,ka)].push_back(i);//将i节点压入所属的联通块
         vis[i]=;//一边清空vis数组
     }
     for(int i=;i<n;i++)
     if(gra[i].size()>){//联通块的点数为1时生成树数量是1
         memset(mat,,sizeof mat);//清空矩阵
         int len=gra[i].size();
         for(int j=;j<len;j++)
         for(int k=j+;k<len;k++){//构造这个联通块的矩阵（有重边）
             int u=gra[i][j],v=gra[i][k];
             if(g[u][v]){
                 mat[k][j]=(mat[j][k]-=g[u][v]);
                 mat[k][k]+=g[u][v];mat[j][j]+=g[u][v];
             }
         }
         ans=ans*det(mat,gra[i].size()-)%p;
         for(int j=;j<len;j++)fa[gra[i][j]]=i;//缩点
     }
     for(int i=;i<n;i++)
     {
         gra[i].clear();
         ka[i]=fa[i]=find(i,fa);
     }
 }
 int main(){
     while(scanf("%lld%lld%lld",&n,&m,&p),n){
         for(int i=;i<m;i++){
             int u,v,w;
             scanf("%d%d%d",&u,&v,&w);
             u--;v--;
             e[i]=(edge){u,v,w};
         }
         sort(e,e+m,cmp);
         memset(g,,sizeof g);
         ans=;
         for(ll i=;i<n;i++)ka[i]=fa[i]=i;
         for(ll i=;i<=m;i++){//边从小到大加入
             if(i&&e[i].w!=e[i-].w||i==m)//处理完长度为e[i-1].w的所有边
                 matrix_tree();//计算生成树
             ll u=find(e[i].u,fa),v=find(e[i].v,fa);//连的两个缩点后的点
             if(u!=v)//如果不是一个
             {
                 vis[v]=vis[u]=;
                 ka[find(u,ka)]=find(v,ka);//两个分量在一个联通块里。
                 g[u][v]++,g[v][u]++;//邻接矩阵
             }
         }
         int flag=;
         for(int i=;i<n;i++)if(fa[i]!=fa[i-])flag=;
         printf("%lld\n",flag?ans%p:);//注意p可能为1，这样m=0时如果ans不%p就会输出1
     }
 }