Unique MST

Unique MST

Time Limit: 3000/1000MS (Java/Others)     Memory Limit: 65535/65535KB (Java/Others)

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≤100), 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.(1≤xi≤n,1≤yi≤n,xi≠yi,0≤wi≤10000).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 and output

Sample Input	Sample Output
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	3 Not Unique!

Hint

The data used in this problem is unofficial data prepared by Nilil. So any mistake here does not imply mistake in the offcial judge data.

Source

POJ Monthly--2004.06.27 srbga@POJ

 

判断给定的图的最小生成树是否唯一，如果唯一输出最小生成树上所有树枝权值之和，否则输出Not Unique!

 

Kruskal求最小生成树。如果最小生成树不唯一，则必定存在权值相同的边。

 

#include<stdio.h>
#include<algorithm>
using namespace std;
int n,m;
struct EG
{
    int x,y,w;
}edge[5050];
bool cmp(const EG & u,const EG & v)
{
    return u.w < v.w;
}
class UFS{
    public:
    int fa[111],ra[111];
void ini()
{
    int i;
    for(i=1;i<=n;++i)ra[fa[i] = i] = 1;
}
int fin(int x)
{
    if(fa[x] == x)return x;
    return fa[x] = fin(fa[x]);
}
void uni(int x,int y)
{
    int a = fin(x),b = fin(y);
    if(a == b)return;
    if(ra[a] < ra[b])
    {
        fa[a] = b;
        ra[b] += ra[a];
    }
    else
    {
        fa[b] = a;
        ra[a] += ra[b];
    }
}
}s1,s2;
int main()
{
    int t,i,ans,f;
    scanf("%d",&t);
R:    while(t--)
    {
        scanf("%d%d",&n,&m);
        s1.ini();
        for(i=1;i<=m;++i)
        {
            scanf("%d%d%d",&edge[i].x,&edge[i].y,&edge[i].w);
            if(s1.fin(edge[i].x) != s1.fin(edge[i].y))s1.uni(edge[i].x,edge[i].y);
        }
        f = s1.fin(1);　　//判断图是否连通，否则直接输出0
        for(i=2;i<=n;++i)
        {
            if(s1.fin(i) != f)
            {
                puts("0");
                goto R;
            }
        }
        sort(edge,edge + m + 1,cmp);
        s2.ini();
        ans = 0;
        for(i=1;i<=m;++i)
        {
            if(s2.fin(edge[i].x) != s2.fin(edge[i].y))　　//如果第i条边可以被添加进来，
            {
                if(i + 1 <= m && edge[i + 1].w == edge[i].w)　　//则看看下一条边（第（i+1）条边）是否和这条边权值相等；
                {
                    if(s2.fin(edge[i + 1].x) != s2.fin(edge[i + 1].y))　　//且在第i条边被添加之前，第（i+1）条边是否就可以被添加。
                    {
                        s2.uni(edge[i].x,edge[i].y);　　//然后判断在第i条边被添加后，
                        if(s2.fin(edge[i + 1].x) == s2.fin(edge[i + 1].y))　　//第（i+1）条边就不能被添加了。
                        {　　　　　　　　　　　　　　　　　　//如果以上条件都满足，则说明第（i+1）条边可以在第i条边被添加之前就可以被添加进来，即树枝选择不唯一，
                            puts("Not Unique!");　　　　//最小生成树也就不唯一。
                            goto R;
                        }
                    }
                }
                s2.uni(edge[i].x,edge[i].y);
                ans += edge[i].w;
            }
        }
        printf("%d
",ans);
    }
    return 0;
}