bzoj1016【最小生成树计数】-优快云博客

本文链接：https://blog.youkuaiyun.com/nikelong0/article/details/50803343

1016: [JSOI2008]最小生成树计数

Time Limit: 1 Sec Memory Limit: 162 MB
Submit: 4194 Solved: 1689
[ Submit][ Status][ Discuss]

Description

现在给出了一个简单无向加权图。你不满足于求出这个图的最小生成树，而希望知道这个图中有多少个不同的最小生成树。（如果两颗最小生成树中至少有一条边不同，则这两个最小生成树就是不同的）。由于不同的最小生成树可能很多，所以你只需要输出方案数对31011的模就可以了。

Input

第一行包含两个数，n和m，其中1<=n<=100; 1<=m<=1000; 表示该无向图的节点数和边数。每个节点用1~n的整数编号。接下来的m行，每行包含两个整数：a, b, c，表示节点a, b之间的边的权值为c，其中1<=c<=1,000,000,000。数据保证不会出现自回边和重边。注意：具有相同权值的边不会超过10条。

Output

输出不同的最小生成树有多少个。你只需要输出数量对31011的模就可以了。

Sample Input

4 6
1 2 1
1 3 1
1 4 1
2 3 2
2 4 1
3 4 1

Sample Output

HINT

Source

我蒟蒻，实在不会，我知道应该会用到kirchhoff矩阵，但不知道怎么搞。

然后搜题解，发现算法是这样的：

首先，考虑kruskal算法，求出最小生成树，我们会发现最小生成树种每种权值被使用的边是一样的(假设wi的边被用了k条，一定不会找到该条边用k-2条，另一条比它权值小，还有一条更大，因为如果是这样，权值更小的那条和当前权值这一条一定也可以满足连通性，也就是这种新的生成树更小，就会产生矛盾)

（权值从小到大排序）对于权值相同的边，我们放在一起讨论:

一组权值相同的边，只会存在成环和不成环的情况，成环的情况在最最小生成树里面一定会不用某些边，也就是我们会知道当前这组权值相同的边用几条，然后计算出选择方法（成环的才能进行选择，才会影响到方案，不成环的必须被选择）

也就是说，我们独立考虑每一种权值的边的选择方案，然后总的方案就是把每一种权值的边的方案乘起来。

每一种权值的边的选择方案可以用kirchhoff矩阵计算(边数<=10,最差计算1000次，然后- -)

然后对于代码我还是有一点不熟悉：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<queue>
#include<cmath>
using namespace std;
//http://blog.youkuaiyun.com/jarily/article/details/8902509
const int mod=31011;
int n,m;
struct edge
{
	int u,v,w;
}e[1010];
bool cmp(edge a,edge b)
{
	return a.w<b.w;
}
int f[105],U[105];
bool vis[105];
int G[105][105],C[105][105];
vector<int >V[105];
int find(int x,int f[])
{
	if(x==f[x])return x;
	return find(f[x],f);
}
int det(int a[][105],int n)
{
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<n;j++)a[i][j]%=mod;
	}
	int ret=1;
	for(int i=1;i<n;i++)
	{
		for(int j=i+1;j<n;j++)
		{
			while(a[j][i])
			{
				int t=-a[i][i]/a[j][i];
				for(int k=i;k<n;k++)
				{
					a[i][k]=(a[i][k]+t*a[j][k])%mod;
				}
				for(int k=i;k<n;k++)swap(a[i][k],a[j][k]);
				ret=-ret;
			}
		}
		if(a[i][i]==0)return 0;
		ret=ret*a[i][i]%mod;
	}
	if(ret<0)
	{
		ret=-ret;
	}
	return (ret+mod)%mod;
}
void solve()
{
	for(int i=1;i<=n;i++)
	{
		f[i]=i;
		vis[i]=0;
	}
	int pre=-1;
	int ans=1;
	for(int k=0;k<=m;k++)
	{
		if(e[k].w!=pre||k==m)
		{
			for(int i=1;i<=n;i++)
			if(vis[i])
			{
				vis[i]=0;
				int u=find(i,U);
				V[u].push_back(i);
			}
		    //vis是处理当前所有联通块（有标记的,把所有的联通快加到祖节点上） 
		
		    for(int i=1;i<=n;i++)
		    {
		    	if(V[i].size()>1)//处理每个联通快 
		    	{
		    		for(int a=1;a<=n;a++)
		    		for(int b=1;b<=n;b++)C[a][b]=0;
		    		
		    		int len=V[i].size();
		    		for(int a=0;a<len;a++)
		    		{
		    			for(int b=a+1;b<len;b++)
		    			{
		    				int a1=V[i][a];
		    				int b1=V[i][b];
		    				C[a][b]=(C[b][a]-=G[a1][b1]);
		    				C[a][a]+=G[a1][b1];
		    				C[b][b]+=G[a1][b1];
		    			}
		    		}
		    		
		    		int ret=(int )det(C,len);
		    		ans=ans*ret%mod;
		    		for(int a=0;a<len;a++)f[V[i][a]]=i;
		    	}
		    }
		    
		    for(int i=1;i<=n;i++)
		    {
		    	U[i]=f[i]=find(i,f);
		    	V[i].clear();
		    }
		    if(k==m)break;
		    pre=e[k].w;
		}
		
		int a=e[k].u;
		int b=e[k].v;
		int a1=find(a,f);
		int b1=find(b,f);
		if(a1==b1)continue;
		vis[a1]=vis[b1]=1;
		U[find(a1,U)]=find(b1,U);
		G[a1][b1]++;
		G[b1][a1]++;
	}
	bool flag=false;
	for(int i=2;i<=n&&!flag;i++)
	{
		if(U[i]!=U[i-1])flag=true;
	}
	if(m==0)flag=true;
	printf("%d\n",(flag)?0:ans%mod);
}
int main()
{
	memset(G,0,sizeof(G));
	scanf("%d%d",&n,&m);
	for(int i=0;i<m;i++)
	{
		scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].w);
	}
	for(int i=1;i<=n;i++)V[i].clear();
	sort(e,e+m,cmp);
	solve();
	return 0;
}