poj 1679 判断MST是不是唯一的 （次小生成树）

判断MST是不是唯一的 如果是唯一的 就输出最小的权值和 如果不是唯一的 就输出Not Unique!

次小生成树就是第二小生成树  如果次小生成树的权值和MST相等  那么MST就不是唯一的

法一：

先求出最小的权值和 然后一条边一条边的删
先标记MST中所使用的边 删边就是屏蔽这条边后 再对剩下的边（不管这些边是否被标记）求MST 如果最后的权值和 与开始算出的最小的那个 相等 就说明不是唯一的

Sample Input

2 //T
3 3 //n m
1 2 1// u v w
2 3 2
3 1 3
4 4
1 2 2
2 3 2
3 4 2
4 1 2
Sample Output

3
Not Unique!

Kruskal

 # include <iostream>
 # include <cstdio>
 # include <cstring>
 # include <algorithm>
 # include <cmath>
 # define LL long long
 using namespace std ;

 int n ;
 const int MAXN=;//最大点数
 const int MAXM=;//最大边数
 int F[MAXN];//并查集使用
 int del[MAXM] ;
 struct Edge
 {
     int u,v,w;
     int tag ;
 }edge[MAXM];//存储边的信息，包括起点/终点/权值

 int tol;//边数，加边前赋值为0
 void addedge(int u,int v,int w)
 {

     edge[tol].u=u;
     edge[tol].v=v;
     edge[tol].tag =  ;
     edge[tol++].w=w;
 }
 bool cmp(Edge a,Edge b)
 {//排序函数，讲边按照权值从小到大排序
     return a.w<b.w;
 }
 int find(int x)
 {
     if(F[x]==-)return x;
     else return F[x]=find(F[x]);
 }
 int Kruskal(int d)//传入点数，返回最小生成树的权值，如果不连通返回-1
 {
     memset(F,-,sizeof(F));

     int cnt=;//计算加入的边数
     int ans=;
     for(int i=;i<tol;i++)
     {
         if (i == d)  //屏蔽id为d的这一条边
             continue ;
         int u=edge[i].u;
         int v=edge[i].v;
         int w=edge[i].w;
         int t1=find(u);
         int t2=find(v);
         if(t1!=t2)
         {
             ans+=w;
             F[t1]=t2;
             cnt++;
             edge[i].tag =  ;
         }
         if(cnt==n-)break;
     }
     if(cnt<n-)return -;//不连通
     else return ans;
 }

 int main()
 {

    // freopen("in.txt","r",stdin) ;
     int m ;
     int T ;
     scanf("%d" , &T) ;
     while(T--)
     {
         scanf("%d %d" , &n , &m) ;
         int i ;
         int u , v , w ;
         tol =  ;
         while(m--)
         {
             scanf("%d %d %d" , &u , &v , &w) ;
             addedge(u , v , w) ;
         }

         sort(edge,edge+tol,cmp);
         int ans = Kruskal(-) ;

         int k =  ;
         for (i =  ; i < tol ; i++)
         {
             if (edge[i].tag ==  )
             {
                 del[k] = i ;
                 k++ ;
             }
         }
         bool flag =  ;
         int t_ans ;
         for (i =  ; i < k ; i++)
         {
             t_ans = Kruskal(del[i]) ;
             if (t_ans == ans)
             {
                 flag =  ;
                 break ;
             }
         }
         if (flag)
             printf("Not Unique!\n") ;
         else
             printf("%d\n" , ans) ;

     }
     return  ;
 }

法二 ： Prim

 /*
  * 次小生成树
  * 求最小生成树时，用数组Max[i][j]来表示MST中i到j最大边权
  * 求完后，直接枚举所有不在MST中的边，替换掉最大边权的边，更新答案
  * 点的编号从0开始
  */
 # include <iostream>
 # include <cstdio>
 # include <cstring>
 # include <algorithm>
 # include <cmath>
 # define LL long long
 using namespace std ;

 int n ;
 const int MAXN=;
 const int INF=0x3f3f3f3f;
 bool vis[MAXN];
 int lowc[MAXN];
 int pre[MAXN];
 int Max[MAXN][MAXN];//Max[i][j]表示在最小生成树中从i到j的路径中的最大边权
 bool used[MAXN][MAXN];
 int cost[MAXN][MAXN];
 int Prim()
 {
     int ans=;
     memset(vis,false,sizeof(vis));
     memset(Max,,sizeof(Max));
     memset(used,false,sizeof(used));
     vis[]=true;
     pre[]=-;
     for(int i=;i<n;i++)
     {
         lowc[i]=cost[][i];
         pre[i]=;
     }
     lowc[]=;
     for(int i=;i<n;i++)
     {
         int minc=INF;
         int p=-;
         for(int j=;j<n;j++)
             if(!vis[j]&&minc>lowc[j])
             {
                 minc=lowc[j];
                 p=j;
             }
         if(minc==INF)return -;
         ans+=minc;
         vis[p]=true;
         used[p][pre[p]]=used[pre[p]][p]=true;
         for(int j=;j<n;j++)
         {
             if(vis[j])Max[j][p]=Max[p][j]=max(Max[j][pre[p]],lowc[p]);
             if(!vis[j]&&lowc[j]>cost[p][j])
             {
                 lowc[j]=cost[p][j];
                 pre[j]=p;
             }
         }
     }
     return ans;
 }

 int smst(int ans)
 {
     int Min=INF;
     for(int i=;i<n;i++)
         for(int j=i+;j<n;j++)
             if(cost[i][j]!=INF && !used[i][j])
             {
                 Min=min(Min,ans+cost[i][j]-Max[i][j]);
             }
     if(Min==INF)return -;//不存在
     return Min;
 }

 int main()
 {
    // freopen("in.txt","r",stdin) ;
     int T;
     int m;
     scanf("%d",&T);
     while(T--)
     {
         scanf("%d%d",&n,&m);
         int u,v,w;
         for(int i=;i<n;i++)
             for(int j=;j<n;j++)
             {
                 if(i==j)cost[i][j]=;
                 else cost[i][j]=INF;
             }
         while(m--)
         {
             scanf("%d%d%d",&u,&v,&w);
             u--;v--;
             cost[u][v]=cost[v][u]=w;
         }
         int ans=Prim();
         if(ans==-)
         {
             printf("Not Unique!\n");
             continue;
         }
         if(ans==smst(ans))printf("Not Unique!\n");
         else printf("%d\n",ans);
     }
     return ;
 }