（最小生成树的计数） bzoj 1060

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

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

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

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

8

科普一下

最小生成树的性质。

做这道题要明白最小生成树的两个性质：

1.两个不同的最小生成树的边权排序之后得到的序列是完全一样的。

理解：

设最小生成树有n条边，任意两棵最小生成树分别称为A, B, 如果e是一条边，用w(e)表示该边的权值。

A的边按权值递增排序后为a1, a2,……an w(a1)≤w(a2)≤……w(an)

B的边按权值递增排序后为b1, b2,……bn w(b1)≤w(b2)≤……w(bn)

设i是两个边列表中，第一次出现不同边的位置，ai≠bi

不妨设w(ai)≥w(bi)

情形1 如果树A中包含边bi，则一定有j>i使得 bi=aj ,事实上,这时有 w(bi)=w(aj)≥w(ai) ≥w(bi) 故 w(bi)=w(aj)=w(ai)，在树A的边列表中交换边ai和 aj的位置并不会影响树A的边权有序列表，两棵树在第i个位置的边变成同一条边。

情形2 树A中并不包含边bi，则把bi加到树A上，形成一个圈，由于A是最小生成树，这个圈里任意一条边的权值都不大于w(bi) ，另外，这个圈里存在边aj不在树B中。因此，有w(aj)≤w(bi)，且j>i (因为aj不在B中)。于是，有w(bi)≤w(ai)≤w(aj)≤w(bi)，因此 w(ai)= w(aj) = w(bi)。那么在树A中把aj换成bi仍然保持它是一棵最小生成树，并不会影响树A的边权有序列表，并且转换成情形1。

2.相同权值的边算完之后树的连通性是一样的。

若连通性不同，说明还可以往进加当前权值的边啊，那就是没算完。

根据这两个性质，用乘法原理，dfs就可以了。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cmath>
#include<algorithm>
#include<cstdlib>
using namespace std;
const int Mod=31011;
int n,m,sum;
int fa[105];
struct node
{
    int x,y,w;
}e[1005];
bool cmp(node aa,node bb)
{
    return aa.w<bb.w;
}
struct data
{
    int l,r,num;
}a[1005];
/*int find(int x)
{
    if(x!=fa[x])
        fa[x]=find(fa[x]);
    return x;
}*///这样写是WA的啊
int find(int x)
{
    if(x==fa[x])
        return x;
    return find(fa[x]);
}
void dfs(int x,int now,int k)
{
    if(now==a[x].r+1)
    {
        if(k==a[x].num)
            sum++;
        return ;
    }
    int fx,fy;
    fx=find(e[now].x),fy=find(e[now].y);
    if(fx!=fy)
    {
        fa[fx]=fy;
        dfs(x,now+1,k+1);
        fa[fx]=fx;
    }
    dfs(x,now+1,k);
}
int main()
{
    int tot=0,cnt=0;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        fa[i]=i;
    for(int i=1;i<=m;i++)
        scanf("%d%d%d",&e[i].x,&e[i].y,&e[i].w);
    sort(e+1,e+1+m,cmp);
    for(int i=1;i<=m;i++)
    {
        if(e[i].w!=e[i-1].w)
        {
            a[cnt].r=i-1;
            a[++cnt].l=i;
        }
        int fx,fy;
        fx=find(e[i].x),fy=find(e[i].y);
        if(fx!=fy)
        {
            fa[fx]=fy;
            a[cnt].num++;
            tot++;
        }
    }
    a[cnt].r=m;
    if(tot!=n-1)
    {
        printf("0
");
        return 0;
    }
    for(int i=1;i<=n;i++)
        fa[i]=i;
    int ans=1;
    for(int i=1;i<=cnt;i++)
    {
        sum=0;
        dfs(i,a[i].l,0);
        ans=(ans*sum)%Mod;
        for(int j=a[i].l;j<=a[i].r;j++)
        {
            int fx,fy;
            fx=find(e[j].x),fy=find(e[j].y);
            if(fx!=fy)
            {
                fa[fx]=fy;
            }
        }
    }
    printf("%d
",ans);
    return 0;
}

（最小生成树的计数） bzoj 1060

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

Description

Input

Output

Sample Input

Sample Output

HINT

Source