ACM/ICPC 之 判别MST唯一性-Kruskal解法(POJ1679)

判别MST是否唯一的例题。

---

POJ1679-The Unique MST

　

　　题意：给定图，求MST(最小生成树)是否唯一，唯一输出路径长，否则输出Not Unique!

　　题解：MST是否唯一取决于是否有两边权值相同(其中一条边在第一次求得的MST内，另一条在MST外)的情况。

　　　　　如果存在这样的边，则需要逐次删除MST内的该边，再次求MST，如果此次求得的MST路长与第一次MST相同，则确实存在不唯一的MST

　　　　　否则，一定不存在多条MST。

 //Kruskal-判断MST是否唯一
 //Time:0MS    Memory:868K
 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<algorithm>
 using namespace std;

 #define MAX 101

 struct Edge {
     int u, v;
     int w;
     bool used;    //First Used
     bool del;    //Kruskal是否不考虑此边
     friend bool operator < (Edge e1, Edge e2) { return e1.w < e2.w; }
 }e[MAX*MAX];

 int n, m;
 bool first;    //是否第一次求MST
 int fa[MAX];
 int del[MAX*MAX], len;    //须逐次删除的边
 int minroad;    //第一次MST结果

 int Find(int x)
 {
     return fa[x] <  ? x : fa[x] = Find(fa[x]);
 }

 void Union(int r1, int r2)
 {
     r1 = Find(r1);
     r2 = Find(r2);
     int num = fa[r1] + fa[r2];
     if (fa[r1] < fa[r2])
     {
         fa[r2] = r1;
         fa[r1] = num;
     }
     else {
         fa[r1] = r2;
         fa[r2] = num;
     }
 }

 bool kruskal()
 {
     memset(fa, -, sizeof(fa));
     int num = ;
     int mind = ;
     for (int i = ; i < m; i++)
     {
         if (e[i].del)    continue;
         if (Find(e[i].u) == Find(e[i].v))    continue;
         Union(e[i].u, e[i].v);
         if (first) {
             minroad += e[i].w;
             e[i].used = true;
         }
         mind += e[i].w;
         if (mind > minroad) return true;
         if (++num == n - ) break;
     }

     return false;
 }

 int main()
 {
     int T;
     scanf("%d", &T);
     while (T--)
     {
         scanf("%d%d", &n, &m);
         memset(e, , sizeof(e));
         for (int i = ; i < m; i++)
             scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);

         len = ;
         sort(e, e + m);
         for (int i = ; i < m; i++)
             if (e[i].w == e[i + ].w)
             {
                 if(del[len-] != i) del[len++] = i;
                 del[len++] = i + ;
             }

         minroad = ;
         first = true;
         kruskal();
         first = false;

         bool unique = true;
         for (int i = ; i < len; i++)
         {
             if (!e[del[i]].used) continue;    //使用过的才删除
             e[del[i]].del = true;    //删除
             if (!kruskal())
             {
                 printf("Not Unique!\n");
                 unique = false; break;
             }
             e[del[i]].del = false;    //恢复
         }

         if (unique)
             printf("%d\n", minroad);
     }

     return ;
 }