POJ--1679--The Unique MST



The Unique MST Crawling in process... Crawling failed Time Limit:1000MS    Memory Limit:10000KB    64bit IO Format:%I64d & %I64u

Submit Status Practice POJ 1679

 

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

3
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

6 7
1 3 1
1 2 2
2 3 3
3 4 0
4 6 5
4 5 4
5 6 6

Sample Output

3
Not Unique!

12

题意：给定一个连通无向网，判断其最小生成树

     是否唯一，唯一则直接输出该权值，否则

     输出"Not Unique!"。

思路：先求一次最小生成树【只选权值不为0的边】,          
         

        记下总权值和各条边的下标，再依次枚举去掉
         

         每条边之后生成的最小生成树总权值是否改变，
          
          有一次不变则说明最小生成树不唯一,所有都
       
         改变则说明最小生成树唯一.

       【关键：枚举时只选 择权值不为0的边，因为

         权值为0的边选了的话，后面不选这条边也会

        产生相同总权值的最小生成树(在2个不同连通

          分量上)，故误判为不唯一 , 见第三个样例。 

          但其实此时，最小生成树是唯一的。但不能

          直接不存权值为 0 的边，因会破坏原图结构.】

代码如下：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
int flag[12000], n, used[12000];
struct node
{
	int s, d, c;
}road[12000];
bool cmp(const node& a, const node& b)
{
	return a.c<b.c;
}
void init()
{
	for(int i=1;i<=n;i++)
		flag[i]=i;
}
int find(int x)
{
	return x==flag[x] ? x : flag[x]=find(flag[x]);
}
using namespace std;
int main()
{
#ifdef OFFLINE
	freopen("t.txt","r",stdin);
#endif
	int m, i, j, t;
	scanf("%d", &t);
	while(t--){
		scanf("%d %d", &n, &m);
		i=1;  j=m;
		while(j--){
			scanf("%d %d %d", &road[i].s, &road[i].d, &road[i].c);
			i++;
		}
		sort(road+1, road+i, cmp);//按权值小到大排序
		init();
		int num=0, ans=0, p=1, L, r;
		for(i=1;i<=m;i++){
			if(road[i].c != 0){//只考虑权值不为0的边
				L=find(road[i].s), r=find(road[i].d);
				if(L != r){
					ans+=road[i].c;
					used[p++]=i;//记录第一次构造最小生成树的边下标
					flag[L]=r; //合并不同连通分量
				}
			}
		}
		int ans1=0, tip=0;
		for(i=1;i<p;i++){//依次删去每条边构造最小生成树
			ans1=num=0, 	init();//初始化
			for(j=1;j<=m;j++){
				if(j != used[i]&&road[j].c != 0){//只考虑权值不为0的边
					L=find(road[j].s), r=find(road[j].d);
					if(L != r){
						ans1+=road[j].c;
						flag[L]=r;   
					}
				}
			}
			if(ans == ans1){//有一种相同则跳出循环(MST不唯一)
				tip++;   break;
			}
		}
		if(tip==0)
			printf("%d\n", ans);
		else
			printf("Not Unique!\n");
	}
	return 0;
}