BZOJ 题目1016: [JSOI2008]最小生成树计数（Kruskal+Matrix_Tree）

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

Time Limit: 1 Sec  Memory Limit: 162 MB

Submit: 3569  Solved: 1425

[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

8

HINT

Source

[Submit][Status][Discuss]


HOME Back

感觉这个oj还是很好用的，而且题也不错，没那么多废话，

调试了很久还是不是能完全的理解，按别人的代码一步步敲了，，a了

ac代码

/**************************************************************
    Problem: 1016
    User: kxh1995
    Language: C++
    Result: Accepted
    Time:60 ms
    Memory:9280 kb
****************************************************************/

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<vector>
#include<stdlib.h>
#define mod 31011
using namespace std;
struct s
{
    int u,v,w;
}edge[1010];
int cmp(const void *a,const void *b)
{
    return (*(struct s *)a).w-(*(struct s *)b).w;
}
int n,m;
int pre[1010],f[1010],vis[1010];
int G[1010][1010],C[1010][1010];
int find(int x,int *pre)
{
    if(pre[x]==x)
        return x;
    return pre[x]=find(pre[x],pre);
}
vector<int>vt[1010];
void init()
{
    int i;
    for(i=0;i<=n;i++)
    {
        f[i]=i;
        vis[i]=0;
        vt[i].clear();
    }
}
int det(int a[][1010],int n)//<span class="comment" style="font-family: arial, verdana, helvetica, sans-serif;">生成树计数:Matrix-Tree定理 </span><span style="font-family: arial, verdana, helvetica, sans-serif;"> </span>
{
    int i,j,k;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            a[i][j]%=mod;
        }
    }
    int ret=1;
    for(i=1;i<n;i++)
    {
        for(j=i+1;j<n;j++)
        {
            while(a[j][i])
            {
                int t=a[i][i]/a[j][i];
                for(k=i;k<n;k++)
                {
                    a[i][k]=(a[i][k]-a[j][k]*t)%mod;
                }
                for(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;
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        int i,j,k;
        memset(G,0,sizeof(G));
        for(i=0;i<m;i++)
        {
            scanf("%d%d%d",&edge[i].u,&edge[i].v,&edge[i].w);
        }
        if(m==0)
        {
            printf("0\n");
            continue;
        }
        qsort(edge,m,sizeof(edge[0]),cmp);
        init();
        int w=-1,a,b;
        long long ans=1;
        for(k=0;k<=m;k++)
        {
            if(edge[k].w!=w||k==m)
            {
                for(i=1;i<=n;i++)
                {
                    if(vis[i])
                    {
                        int u=find(i,pre);
                        vt[u].push_back(i);
                        vis[i]=0;
                    }
                }
                for(i=1;i<=n;i++)
                {
                    if(vt[i].size()>1)
                    {
                        int len=vt[i].size();
                    //  memset(C,0,sizeof(C));
                        for(a=1;a<=n;a++)
                            for(b=1;b<=n;b++)
                                C[a][b]=0;
                        for(a=0;a<len;a++)
                        {
                            for(b=a+1;b<len;b++)
                            {
                                int a1=vt[i][a];
                                int b1=vt[i][b];
                                C[b][a]-=G[a1][b1];
                                C[a][b]=C[b][a];
                                C[a][a]+=G[a1][b1];
                                C[b][b]+=G[a1][b1];
                            }
                        }
                        int ret=det(C,len);
                //      printf("+++++%d\n",ret);
                        ans=(ans*ret)%mod;
                        for(a=0;a<len;a++)
                        {
                            f[vt[i][a]]=i;
                        }
                    }
                }
                for(i=1;i<=n;i++)
                {
                    pre[i]=f[i]=find(i,f);
                    vt[i].clear();
                }
                if(k==m)
                    break;
                w=edge[k].w;
            }
            int a=edge[k].u;
            int b=edge[k].v;
            int fa=find(a,f);
            int fb=find(b,f);

            if(fa!=fb)
            {
                int fx=find(fa,pre),fy=find(fb,pre);
                vis[fa]=vis[fb]=1;
                pre[fx]=fy;
                G[fa][fb]++;
                G[fb][fa]++;
            }
        }
    //  printf("%d\n",ans);
        int flag=0;
        for(i=2;i<=n;i++)
        {
            if(flag)
                break;
            if(pre[i]!=pre[i-1])
                flag=1;
        }
        if(!flag)
            printf("%lld\n",ans);
        else
            printf("0\n");
    }

版权声明：本文为博主原创文章，未经博主允许不得转载。