HDU 4408 Minimum Spanning Tree 最小生成树计数

http://acm.hdu.edu.cn/showproblem.php?pid=4408

题意：求最小生成树个数

题解：对于Kruskal算法，我们发现，最小生成树要想用多种方法就要有长度相同的边。而且，我们发现，kruskal处理完长度所有为c1的边之后，他的结果就是用长度为c1的边生成了一棵树，而且这棵树对于下面的影响都是一样的，因为只有效果重复的边才不会被加入集合，所以我们只需要记录每一个阶段的生成树个数然后相乘就可以了。

  实现起来，在一个阶段内，要想有多种方法，必定是有的边成环了，也就是形成了联通块，所以我们只需要找到联通块，然后在这些联通块内生成树就可以了。我们用并查集维护缩点。具体细节看注释。

代码：

#include <iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<cstring>
using namespace std;
typedef long long ll;
const int maxn =105;
const int maxm =1005;
//生成树计数模板
ll mode;
ll a[maxn][maxn];//生成树计数模板
ll det(int n){
	int i,j,k;
	ll ans=1;
	for(i=0;i<n;i++)for(j=0;j<n;j++)a[i][j]%=mode;
	for(i=0;i<n;i++){
		for(j=i+1;j<n;j++){
			while(a[j][i]){
				int tmp=a[i][i]/a[j][i];
				for(k=i;k<n;k++){
					a[i][k]=((a[i][k]-tmp*a[j][k])%mode+mode)%mode;
					swap(a[i][k],a[j][k]);
				}
				ans=-ans;
			}
		}
		if(a[i][i]==0)return 0;
		ans=ans*a[i][i]%mode;
	}
	return (ans%mode+mode)%mode;
}
///并查集部分
//over_p记录之前已经更新过的所有的关系，now_p记录当前这一层的关系
int now_p[maxn],over_p[maxn];
int finde(int x,int p[]){
	return p[x]==x?x:p[x]=finde(p[x],p);
}
void join(int x,int y,int p[]){
	x=finde(x,p);
	y=finde(y,p);
	if(x==y)return ;
	p[x]=y;
	return ;
}
//slove
struct node{
	int u,v,w;
}e[maxm];
bool cmp(node a,node b){
	return a.w<b.w;
}
int n,m;
ll ans;
int vis[maxn];
vector<int> g[maxn];
void init(){
	int i;
	for(i=0;i<n;i++){
		now_p[i]=i;
		over_p[i]=i;
		g[i].clear();
	}
	memset(vis,0,sizeof(vis));
	sort(e,e+m,cmp);
}
int mp[maxn][maxn];
ll max_mst_num(){
	if(m==0)return 0;
	ans=1;
	int i,j;
	int x,y;
	init();
	int now=e[0].w;
	for(i=0;i<=m;i++){
		if(e[i].w==now&&i!=m){
			//查找被缩成的点
			x=finde(e[i].u,over_p);
			y=finde(e[i].v,over_p);
			if(x==y)continue;//之前被缩为一点
			join(x,y,now_p);//在一个集合内等待缩点
			vis[x]=1;
			vis[y]=1;
			mp[x][y]++;//邻接矩阵不再是0，1矩阵，因为这里进行了缩点，要保存这一点所有的关系
			mp[y][x]++;
		}
		else {
			for(j=0;j<n;j++){
				if(vis[j]){
					vis[j]=0;
					g[finde(j,now_p)].push_back(j);//将一个联通块加入一个vector
				}
			}
			for(j=0;j<n;j++){
				if(g[j].size()>1){
					int len=g[j].size();
					memset(a,0,sizeof(a));
					for(x=0;x<len;x++){
						for(y=x+1;y<len;y++){
							int tmp1,tmp2;
							tmp1=g[j][x];
							tmp2=g[j][y];
							a[x][y]=a[y][x]=-mp[tmp1][tmp2];
							a[x][x]+=mp[tmp1][tmp2];
							a[y][y]+=mp[tmp1][tmp2];
							//x,y为点在这一联通块内的编号，计算时用这个编号形成的矩阵
						}
					}
					ans=(ans*det(len-1)%mode+mode)%mode;//对这一联通块生成树计数
					for(x=0;x<len;x++)over_p[g[j][x]]=j;//将这一层的关系记录到全局关系中
				}
			}
			memset(mp,0,sizeof(mp));
			//初始化当前关系为下一轮准备
			for(j=0;j<n;j++){
				now_p[j]=finde(j,over_p);
				g[j].clear();
			}
			now=e[i].w;
			if(i>=m)break;
			i--;
		}
	}
	now=finde(0,over_p);
	for(i=0;i<n;i++)if(finde(i,over_p)!=now)return 0;
	return ans;
}
int main()
{
	int i;
	//freopen("1.txt","r",stdin);
	while(cin>>n>>m>>mode){
		if(n==0&&m==0&&mode==0)break;
		for(i=0;i<m;i++){
			scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].w);
			e[i].v--;
			e[i].u--;//别忘了
		}
		ll ans=max_mst_num();
		ans=(ans%mode+mode)%mode;
		printf("%lld\n",ans);
	}
   // cout << "Hello world!" << endl;
    return 0;
}