HDU3371 Connect the Cities 【最小生成树Kruskal】

Connect the Cities

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)

Total Submission(s): 9856    Accepted Submission(s): 2800

Problem Description

In 2100, since the sea level rise, most of the cities disappear. Though some survived cities are still connected with others, but most of them become disconnected. The government wants to build some roads to connect all of these cities again, but they don’t want to take too much money.  

 

Input

The first line contains the number of test cases.
Each test case starts with three integers: n, m and k. n (3 <= n <=500) stands for the number of survived cities, m (0 <= m <= 25000) stands for the number of roads you can choose to connect the cities and k (0 <= k <= 100) stands for the number of still connected cities.
To make it easy, the cities are signed from 1 to n.
Then follow m lines, each contains three integers p, q and c (0 <= c <= 1000), means it takes c to connect p and q.
Then follow k lines, each line starts with an integer t (2 <= t <= n) stands for the number of this connected cities. Then t integers follow stands for the id of these cities.

 

Output

For each case, output the least money you need to take, if it’s impossible, just output -1.

 

Sample Input

   
   
   
   

    
    
    
    1
6 4 3
1 4 2
2 6 1
2 3 5
3 4 33
2 1 2
2 1 3
3 4 5 6
   
   
   
   

 

Sample Output

   
   
   
   

    
    
    
    1
   
   
   
   

啊啊啊，这题做得要疯了，用了大半天时间。第一次用kruskal解题，大致总结一下这个算法：kruskal就是以边为中心，每次贪心选择最短边以构建一棵最小生成树，并查集的作用是一开始初始化成n棵树，对应n个节点，每次读入一条边时判断该边的起点和终点是否在同一棵树中，若是则不能读取该边，否则会构成环，若不是同一棵树则将这两棵树合并，记录树总数的变量减一，最后若该变量等于1代表最小生成树已经找到了，若遍历所有边后该变量依旧不等于1则没有最小生成树。

题意：给定n个点，m条边和t个已经联通的集合，求最小生成树。

题解：上面已经说过，注意特殊情况，比如一开始树就已经联通的情况，我就被这里坑了8次 @_@

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define maxn 502
#define maxm 25002

int id, pre[maxn];
int count, ans;
struct Node{
	int from, to, val;
} edge[maxm];

void addEdge(int a, int b, int c)
{
	edge[id].from = a;
	edge[id].to = b;
	edge[id++].val = c;
}

int unionFind(int k)
{
	int a = k;
	while(pre[k] != -1) k = pre[k];
	int b;
	while(a != k){
		b = pre[a];
		pre[a] = k;
		a = b;
	}
	return k;
}

int cmp(const void* a, const void* b){
	return ((Node *)a)->val - ((Node *)b)->val;
}

bool kruskal()
{
	qsort(edge, id, sizeof(Node), cmp);
	int x, y, i;
	for(i = 0; i < id; ++i){
		x = unionFind(edge[i].from);
		y = unionFind(edge[i].to);
		if(x != y){
			ans += edge[i].val;
			--count; pre[y] = x;
			if(1 == count) return true;
		}		
	}

	return 1 == count;
}

int main()
{
	//freopen("stdin.txt", "r", stdin);
	int cas, n, m, k, t, a, b, c, i;
	scanf("%d", &cas);
	while(cas--){
		memset(pre, -1, sizeof(pre));
		scanf("%d%d%d", &n, &m, &k);
		for(i = id = 0; i < m; ++i){
			scanf("%d%d%d", &a, &b, &c);
			addEdge(a, b, c);
		}
		count = n; ans = 0;
		for(i = 0; i < k; ++i){
			scanf("%d%d", &t, &a);
			a = unionFind(a);
			while(--t){
				scanf("%d", &b);
				b = unionFind(b);
				if(a != b){
					pre[b] = a;
					--count;
				}
			}
		}
		if(!kruskal()) printf("-1\n");
		else printf("%d\n", ans);
	}
	return 0;
}