洛谷P4208 [JSOI2008]最小生成树计数——题解

题目传送

　　前置知识：对于同一个图的所有最小生成树，权值相等的边的数量相同。

　　可以简单证明一下：

　　　　我们可以从kruskal的过程考虑。这个算法把所有边按权值大小从小到大排序，然后按顺序看每条边，只要加上这条边后不会形成连通块，就加上。

　　　　以上过程其实等价于先将所有权值等于第一条边的边都加进图中，然后一个个删边，使图中无环。设权值等于第一条边的边数为i，下次再将所有权值等于第i+1条边的边都加进图中。。。直至算过最后一条边，或图中刚好剩下了n-1条边（n为图的点的个数）。

　　　　发现加完一批边后要删的边的个数等于形成的“最小环”的个数（这里最小环是指：对于一个最小环，不存在一组边使得通过这组边把环“从中间切开”后，被切开的环的两部分可与这组边形成两个新环（即不是依照国际标准的定义，而是为了方便在本文现定义的）；同时最小环边数不一定小）。

　　　　为什么呢？从一个最小环开始考虑：

　　　　　　若不存在其他的某个最小环v与这个环u有公共边，那么只要任意删一条边就能减少一个最小环。

　　　　　　若存在，这时删边就有两种情况：

　　　　　　　　删公共边：首先u和v原来的最小环形态都会被破坏，最小环数目-2。然后，发现u和v剩下的部分又可以组成一个新的最小环，所以最小环的数目又+1。所以最小环数目-1；

　　　　　　　　不删公共边：u的最小环形态被破坏，且不会生成新的最小环，所以最小环数目-1。

　　　　　　综上，可知要删的边的数目==最小环的数目，且要删的边可是最小环上的任意边。

　　　　由于加完一批边后，最小环的数目确定，所以删的边的数目也确定。故图生成的所有最小生成树边权相等的边数目也相等。所以我们可以先跑一次最小生成树，记录下每种边权在最小生成树中的出现次数

　　同时我们还发现，当处理完一批权值等于x的边后，这个图的连通性（即都有哪些点连通）是唯一的。即使不用kruskal做最小生成树，设用了算法A做最小生成树，如果只保留权值等于x的边，那么保留的图的连通性与用kruskal做到处理完权值等于x的边时是一样的。否则，只可能连通的点数小于用kruskal做到时的连通的点数（因为kruskal全部地考虑过了权值等于x的边，其他算法不可能比全部还多吧）。但这是不成立的，因为若成立，就说明用kruskal做的最小生成树X中权值等于x的边比A算法得到的最小生成树Y中权值等于x的边的边数多一。由于kruskal是从小边开始贪心考虑所有边的，那么X的权值和一定小于Y，与Y是最小生成树矛盾；并且这也与上文的定理矛盾。

　　设最小生成树边的权值从小到大分别为x1,x2,...,xk，那么构造一个最小生成树只需要分k步，每步都是在前面步骤都做了的基础上，选择一个对所有权值等于x的边的保留方案。由于每步造成的对连通性的影响都是一样的，即每步的结果都是一样的，所以可以用乘法原理，将每步的保留方案数乘起来再去模就是答案了。

　　怎么求每步的保留方案数呢？由于题目限制权值相等的边不超过10条，所以用dfs枚举就是了，同时可用并查集验证可行性。注意：如果dfs要回溯到之前状态，那么并查集不能路径压缩，否则并查集的状态难以回溯到之前的状态。

代码：

 #include<iostream>
 #include<cstdio>
 #include<algorithm>

 using namespace std;

 const int N=,M=,mod=;

 struct Edge{
     int from,to,len;
 }e[M];

 int n,m,f[N],l[M],r[M],cnt,tot,ecnt[M];
 int x;

 char ch;

 inline int read()
 {
     x=;
     ch=getchar();
     while(!isdigit(ch)) ch=getchar();
     while(isdigit(ch)) x=(x<<)+(x<<)+(ch^),ch=getchar();
     return x;
 }

 inline bool cmp(const Edge &a,const Edge &b)
 {
     return a.len<b.len;
 }

 int yfa(int u)
 {
     if(u==f[u])
         return u;
     else
         return f[u]=yfa(f[u]);
 }    

 int fa(int u)
 {
     if(u==f[u])
         return u;
     else
         return fa(f[u]);
 }
 //能/不能路径压缩的并查集查找
 void dfs(int wei,int kin,int had)//当前看的边数组的位置，当前看的边的种类，当前已经取的边的数目
 {
     int b1,b2;
     b1=fa(e[wei].from);//dfs要回溯状态，所以dfs里并查集查找操作不能路径压缩
     b2=fa(e[wei].to);
     if(r[kin]-wei++had==ecnt[kin])//如果已经取的边的数目+还能取的数目=要取的边的数目，就只能取了
     {
         if(b1==b2) return;
         if(had==ecnt[kin]-)
         {
             cnt++;
             return;
         }
         f[b1]=b2;
         dfs(wei+,kin,had+);
         f[b1]=b1;
         return;
     }
     if(b1!=b2)
     {
         if(had+==ecnt[kin])
             cnt++;
         else
         {
             f[b1]=b2;
             dfs(wei+,kin,had+);
             f[b1]=b1;
         }
     }
         dfs(wei+,kin,had);
 }

 int main()
 {
     n=read(),m=read();
     for(int i=;i<=m;++i)
         e[i].from=read(),e[i].to=read(),e[i].len=read();
     sort(e+,e+m+,cmp);
     for(int i=;i<=n;++i)
         f[i]=i;
     int u,v;
     for(int i=;i<=m;++i)
     {
         if(e[i].len==e[i-].len)
         {
             r[tot]++;
         }
         else
         {
             ++tot;
             l[tot]=r[tot]=i;
         }
         if(cnt<n-)
         {
             u=yfa(e[i].from),v=yfa(e[i].to);
             if(u!=v)
             {
                 ecnt[tot]++;
                 f[u]=v;
                 cnt++;
             }
         }
     }
     if(cnt<n-)//注意无解时的判断
     {
         printf("");
         return ;
     }
     long long ans=;
     for(int i=;i<=n;++i) f[i]=i;
     for(int i=;i<=tot;++i)
         if(ecnt[i])
         {
             cnt=;
             dfs(l[i],i,);
             ans=(ans*cnt)%mod;
             for(int j=l[i];j<=r[i];++j)//更新当前步骤做完时图的连通性
             {
                 u=yfa(e[j].from);
                 v=yfa(e[j].to);
                 if(u!=v)
                     f[u]=v;
             }
         }
     printf("%lld",ans);
     return ;
 }