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;
}