poj 1679 The Unique MST 判断最小生成树是否唯一 Prim算法 模板

The Unique MST

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 36109		Accepted: 13175

Description

Given a connected undirected graph, tell if its minimum spanning tree is unique. 

Definition 1 (Spanning Tree): Consider a connected, undirected graph G = (V, E). A spanning tree of G is a subgraph of G, say T = (V', E'), with the following properties: 
1. V' = V. 
2. T is connected and acyclic. 

Definition 2 (Minimum Spanning Tree): Consider an edge-weighted, connected, undirected graph G = (V, E). The minimum spanning tree T = (V, E') of G is the spanning tree that has the smallest total cost. The total cost of T means the sum of the weights on all the edges in E'. 

Input

The first line contains a single integer t (1 <= t <= 20), the number of test cases. Each case represents a graph. It begins with a line containing two integers n and m (1 <= n <= 100), the number of nodes and edges. Each of the following m lines contains a triple (xi, yi, wi), indicating that xi and yi are connected by an edge with weight = wi. For any two nodes, there is at most one edge connecting them.

Output

For each input, if the MST is unique, print the total cost of it, or otherwise print the string 'Not Unique!'.

Sample Input

2
3 3
1 2 1
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的方法好像会比较麻烦，prim的虽然实现比较繁琐但是其中可以直接处理需要的量。如果不知道最小生成树的算法的话应该也不会想知道次小生成树是否存在这样的，所以我就直接贴代码了，做法都附在里面了。还是不知道的话调试或者手模一遍应该就知道了。

---

代码如下：

   

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
using namespace std;
const int inf=0x3f3f3f3f;
int mp[105][105],mpin[105][105],n,m,con[105][105];
int dis[105],vis[105];
int prim(){
    memset(vis,0,sizeof(vis));
    memset(mpin,0,sizeof(mpin));
    int pre[105];
    for(int i=1;i<=n;i++){
        dis[i]=mp[1][i],pre[i]=1;//以第一个结点开始
    }
    vis[1]=1; dis[1]=0;
    int res=0;
    for(int j=1;j<n;j++){
        int index=-1,tmp=inf;
        for(int i=1;i<=n;i++){
            if(!vis[i]&&dis[i]<tmp){
                tmp=dis[i],index=i;//寻找下一个最近的点
            }
        }
        if(index==-1) return res;
        res+=tmp;  vis[index]=1;
        con[index][pre[index]]=con[pre[index]][index]=1;
        //表示这条边已经被使用，之后的更新中就不能再用这条边了
        mpin[index][pre[index]]=mpin[pre[index]][index]=tmp;
        //更新在最小生成树中点间的值
        for(int i=1;i<=n;i++){
            if(vis[i]&&i!=index){
                mpin[index][i]=mpin[i][index]=max(dis[index],mpin[i][pre[index]]);
                //只更新我们已经遍历过的点，找两两结点之间的最长路径
            }
            if(!vis[i]&&mp[index][i]<dis[i]){
                dis[i]=mp[index][i];
                pre[i]=index;
            }
        }
    }
    return res;
}
int main(){
    int t,x,y,z;
    cin>>t;
    while(t--){
        memset(mp,125,sizeof(mp));
        memset(con,0,sizeof(con));
        scanf("%d%d",&n,&m);
        for(int i=0;i<m;i++){
            scanf("%d%d%d",&x,&y,&z);
            mp[x][y]=mp[y][x]=z;
        }
        int ans=prim();
        int flag=0;
        //如果有一条边(i,j)没有被最小生成树使用但是这条边等于树中从i到j所有路径中的最大值；
        //即i到j加上这条边的环上有与该边等长的边，则可替换，即最小生成树不唯一
        for(int i=1;i<=n&&!flag;i++){
            for(int j=1;j<=n;j++){
                if(con[i][j]||mp[i][j]>=inf) continue;
                if(mp[i][j]==mpin[i][j]){
                    flag=1;//树中最长和树外的边长相同则不唯一
                    break;
                }
            }
        }
        if(flag) printf("Not Unique!\n");
        else printf("%d\n",ans);
    }
    return 0;
}