POJ1679 The Unique MST（次小生成树）

可以依次枚举MST上的各条边并删去再求最小生成树，如果结果和第一次求的一样，那就是最小生成树不唯一。

用prim算法，时间复杂度O(n^3)。

 #include<cstdio>
 #include<cstring>
 using namespace std;
 #define MAXN 111
 #define INF (1<<30)
 struct Edge{
     int u,v;
 }edge[MAXN];
 int NE;

 int n,G[MAXN][MAXN];
 int lowcost[MAXN],nearvex[MAXN];
 int prim(bool statue){
     for(int i=;i<=n;++i) lowcost[i]=INF;
     lowcost[]=;
     int res=;
     for(int i=; i<n; ++i){
         int u=-,min=INF;
         for(int v=; v<=n; ++v){
             if(lowcost[v]!=- && lowcost[v]<min){
                 min=lowcost[v];
                 u=v;
             }
         }
         if(u==-) return -;
         if(statue && u!=){
             edge[NE].u=nearvex[u]; edge[NE].v=u;
             ++NE;
         }
         lowcost[u]=-;
         res+=min;
         for(int v=; v<=n; ++v){
             if(lowcost[v]!=- && lowcost[v]>G[u][v]){
                 lowcost[v]=G[u][v];
                 nearvex[v]=u;
             }
         }
     }
     return res;
 }

 bool isUnique(int res){
     for(int i=; i<NE; ++i){
         int tmp=G[edge[i].u][edge[i].v];
         G[edge[i].u][edge[i].v]=G[edge[i].v][edge[i].u]=INF;
         if(prim()==res) return ;
         G[edge[i].u][edge[i].v]=G[edge[i].v][edge[i].u]=tmp;
     }
     return ;
 }

 int main(){
     int t,m,a,b,c;
     scanf("%d",&t);
     while(t--){
         scanf("%d%d",&n,&m);
         for(int i=; i<=n; ++i){
             for(int j=; j<=n; ++j) G[i][j]=INF;
         }
         for(int i=; i<m; ++i){
             scanf("%d%d%d",&a,&b,&c);
             G[a][b]=G[b][a]=c;
         }
         NE=;
         int res=prim();
         if(isUnique(res)) printf("%d\n",res);
         else puts("Not Unique!");
     }
     return ;
 } 

有O(n^2)的算法，详见http://www.cnblogs.com/hxsyl/p/3290832.html。

算法，需要求出MST上任意两点路径上的最长边，删除这条边会形成两个连通分支而那两点就分别在这两个连通分支里；

然后依次枚举所有不在MST上的边，删除边上两点路径上的最长边并加入MST，这样就构成另外一颗生成树了，并且是存在该边的前提下的最小生成树。

计算MST任意两点路径上的最长边，可以在prim算法的过程中求出：每当一个点加入T集合前，计算出所有T集合的点到该点的最长边。

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 #define MAXN 111
 #define INF (1<<30)

 int n,G[MAXN][MAXN];
 bool vis[MAXN][MAXN];
 int lowcost[MAXN],nearvex[MAXN],maxedge[MAXN][MAXN];
 int T[MAXN],NT;
 int prim(){
     memset(vis,,sizeof(vis));
     memset(maxedge,,sizeof(maxedge));
     NT=;
     nearvex[]=;
     for(int i=; i<=n; ++i) lowcost[i]=INF;
     lowcost[]=;

     int res=;
     for(int i=; i<n; ++i){
         int u=-,mincost=INF;
         for(int v=; v<=n; ++v){
             if(lowcost[v]!=- && lowcost[v]<mincost){
                 mincost=lowcost[v];
                 u=v;
             }
         }

         vis[nearvex[u]][u]=vis[u][nearvex[u]]=;
         for(int i=; i<NT; ++i) maxedge[T[i]][u]=maxedge[u][T[i]]=max(maxedge[T[i]][nearvex[u]],mincost);
         T[NT++]=u;

         res+=mincost;
         lowcost[u]=-;
         for(int v=; v<=n; ++v){
             if(lowcost[v]!=- && lowcost[v]>G[u][v]){
                 lowcost[v]=G[u][v];
                 nearvex[v]=u;
             }
         }
     }
     return res;
 }

 int SMST(){
     int res=INF;
     for(int i=; i<=n; ++i){
         for(int j=i+; j<=n; ++j){
             if(vis[i][j] || G[i][j]==INF) continue;
             res=min(res,G[i][j]-maxedge[i][j]);
         }
     }
     return res;
 }

 int main(){
     int t,m,a,b,c;
     scanf("%d",&t);
     while(t--){
         scanf("%d%d",&n,&m);
         for(int i=; i<=n; ++i){
             for(int j=; j<=n; ++j) G[i][j]=INF;
         }
         while(m--){
             scanf("%d%d%d",&a,&b,&c);
             G[a][b]=G[b][a]=c;
         }
         int res=prim();
         if(SMST()==) puts("Not Unique!");
         else printf("%d\n",res);
     }
     return ;
 }