bzoj1016 最小生成树计数

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

Time Limit: 1 Sec  Memory Limit:
162 MB
Submit: 5739  Solved: 2335

[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,0

00。数据保证不会出现自回边和重边。注意：具有相同权值的边不会超过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

8

HINT

Source

题目描述：顾名思义，给出一个有n(1 <= n <= 100)各点，m(1 <= m <= 1,000)条边的无向图，要求求出其最小生成树的个数

推荐一篇写的比较清楚的题解：//http://www.bubuko.com/infodetail-704584.html（没找到原作者，只有爬虫网站转载的文章...）

直观证明一下为什么从权值小到权值大加边，当把权值相同的边全部加进去时，图的连通状态是一定的：

试想现在我该加入权值为val的边了，那么我就先一口气把所有的权值为val的边加进去，那么，这样很可能会使得当前的图中出现环，就不满足树的条件了；现在，我从这个可能有环的图中拆除掉一些边，使得当前的图中保证无环，那么在我的拆除方案中，拆掉某条边之后，不能使得原先连通的部分变成不连通的。为什么？因为一但变成不连通的，那么我就要在这之后用权值更大的边来沟通这两个不连通的连通块，这样势必要付出更大的代价。因此得出结论，在权值为val的边中挑选一些加入最小生成树以后，其连通情况一定是与加入所有权值为val的边的连通情况情况是相同的。

收获：1、之前把matrix tree搞错了，如果点a点b之间有x(x > 1)条边，那么基尔霍夫矩阵当中G[a][b] = -x

            2、这道题的实现可以延伸到很多缩点的问题当中，可以通过一定手段把缩点后在同一集合里的点打上相同的编号，然后重新建边

#pragma warning(disable:4786)
#pragma comment(linker, "/STACK:102400000,102400000")
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<vector>
#include<cmath>
#include<string>
#include<sstream>
#include<bitset>
#define LL long long
#define FOR(i,f_start,f_end) for(int i=f_start;i<=f_end;++i)
#define mem(a,x) memset(a,x,sizeof(a))
#define lson l,m,x<<1
#define rson m+1,r,x<<1|1
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = 31011;
const double PI = acos(-1.0);
const double eps=1e-6;
const int max_edge = 1000 + 5;
const int maxn = 20;
int p[105] , vis[105] , G[105][105];
LL a[maxn][maxn] ;
LL det(int n)//生成树计数:Matrix-Tree定理
{
for(int i=1; i<=n; i++)
for(int j=1; j<=n; j++)
a[i][j]%=mod;
LL 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]-a[j][k]*t)%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;
}
struct Edge
{
int u , v , val;
bool operator < (const Edge & rhs)const
{
return val < rhs.val;
}
}edges[max_edge];
int find(int x)
{
if(x == p[x])
return x;
else
return p[x] = find(p[x]);
}
void init(int n)
{
for(int i =1 ; i<=n; i++)
p[i] = i;
}
void merge(int x , int y)
{
int rx = find(x) , ry = find(y);
if(rx == ry) return ;
p[rx] = ry;
}
LL solve(vector<int>& v)
{
int sz = v.size();
mem(a , 0);
for(int i = 0 ; i < sz ; i++){
for(int j = 0 ; j < sz ; j++){
int u = v[i] , t = v[j];
if(!G[u][t] || u == t) continue;
a[i + 1][j + 1] = -G[u][t];
a[i + 1][i + 1] += G[u][t];
}
}
LL ret = det(sz - 1);
return ret;
}
int main()
{
int n , m , last = 1;
mem(vis , 0);
mem(G ,0);
scanf("%d%d" , &n , &m);
init(n);
for(int i = 1 ; i <= m ;i++){
scanf("%d%d%d" , &edges[i].u , &edges[i].v , &edges[i].val);
}
sort(edges + 1 , edges + 1 + m);
edges[m + 1].val = -1;
LL ans = 1 ;
init(n);
for(int i = 1 ; i <= m ; i++){
int x = p[edges[i].u] , y = p[edges[i].v];
if(x != y){
++G[x][y]; ++G[y][x];
}
if(edges[i].val == edges[i + 1].val) continue;
for(int j = last ; j <= i ; j++){
merge(edges[j].u , edges[j].v);
}
vector<int>v[105];
for(int j = 1 ; j <= n ; j++){
int rj = find(j);
if(!vis[j]){
v[rj].push_back(j);
if(rj != j)
vis[j] = 1;
}
}
for(int j = 1 ; j <= n ; j++){
if(v[j].size() < 2) continue;
ans = ans * solve(v[j]);
ans %= mod;
}
last = i + 1;
}
int root = find(1) , flag = 1;
for(int i = 1 ; i <= n ; i++){
if(find(i) != root){
flag = 0;
break;
}
}
printf("%lld\n" , flag * ans);
return 0;
}