HDOJ 1879 继续畅通工程 Prim算法或Kruskal算法

Problem Description
省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可）。现得到城镇道路统计表，表中列出了任意两城镇间修建道路的费用，以及该道路是否已经修通的状态。现请你编写程序，计算出全省畅通需要的最低成本。
Input
测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N ( 1< N < 100 )；随后的 N(N-1)/2 行对应村庄间道路的成本及修建状态，每行给4个正整数，分别是两个村庄的编号（从1编号到N），此两村庄间道路的成本，以及修建状态：1表示已建，0表示未建。
当N为0时输入结束。
Output
每个测试用例的输出占一行，输出全省畅通需要的最低成本。
Sample Input
3
1 2 1 0
1 3 2 0
2 3 4 0
3
1 2 1 0
1 3 2 0
2 3 4 1
3
1 2 1 0
1 3 2 1
2 3 4 1
0
Sample Output
3
1
0

解题思路：
Prim算法的一点小改变，在寻找将某一结点加入已连通集合的最小代价时，如果该结点与已连通集合中的某一结点有已经修好的边(即已连通)，则最小代价为0；
当然，使用Kruskal算法也是可以的，在添加边的时候可以将那些已经连通的结点用并查集合并到同一个集合中。

AC代码(Prim算法)：

#include<iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;
#define INF 0x3fffffff
#define maxn 101
int map[maxn][maxn];
char map1[maxn][maxn];
int d[maxn];//用于存放连通某一顶点所需要的代价
bool mark[maxn];
int n;//顶点个数
int prim(int s) {
	for (int i = 1; i <= n; i++) {
		d[i] = INF;
		mark[i] = false;
	}
	int newnode = s;
	mark[newnode] = true;
	d[newnode] = 0;
	int ans = 0;//返回值
	for (int i = 1; i < n; i++) {//循环n-1次
		for (int j = 1; j <= n; j++) {
			if (mark[j] || map[newnode][j] == INF) continue;
			if (map1[newnode][j] == '1') {//已修建
				d[j] = 0;
				continue;
			}
			if (d[j] == INF || d[j] > map[newnode][j]) {
				d[j] = map[newnode][j];
			}
		}
		int tmp = INF;
		for (int j = 1; j <= n; j++) {//寻找最小值加入集合
			if (mark[j] || d[j] == INF) continue;
			if (d[j] < tmp) {
				tmp = d[j];
				newnode = j;
			}
		}
		if (tmp == INF) return -1;//不存在最小生成树 提前剪枝
		mark[newnode] = true;
		ans += d[newnode];
	}
	return ans;
}
void init(int x) {
	for (int i = 1; i <= x; i++) {
		for (int j = 1; j <= x; j++) {
			map[i][j] = INF;
			map1[i][j] = '0';
		}
	}
}
int main() {
	while (scanf("%d", &n) != EOF) {
		if (n == 0)break;
		init(n);
		int time = n*(n - 1) / 2;
		int u, v, w; char type;
		for (int i = 1; i <= time; i++) {
			scanf("%d%d%d %c", &u, &v, &w, &type);
			if (type == map1[u][v]) {
				map[u][v] = min(map[u][v], w);
				map[v][u] = map[u][v];
			}
			else if (type=='1') {//更新
				map[u][v] = w;
				map[v][u] = map[u][v];
				map1[u][v] = map1[v][u] = type;
			}
		}
		cout << prim(n) << endl;
	}
	return 0;
}

AC代码(Kruskal算法)：

#include<iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;
#define INF 0x3fffffff
#define maxn 101
int n;//顶点个数
struct edge {
	int u, v, w;
}e[5000];
bool cmp(edge a, edge b) { return a.w < b.w; }
int tree[maxn];
int findroot(int a) {
	if (tree[a] == -1)return a;
	else {
		int tmp = findroot(tree[a]);
		tree[a] = tmp;//路径压缩
		return tmp;
	}
}
bool hebing(int a, int b) {
	a = findroot(a);
	b = findroot(b);
	if (a != b) {
		tree[a] = b;
		return true;
	}
	return false;
}
void init(int x) {
	for (int i = 1; i <= x; i++) {
		tree[i] = -1;
	}
}
int main() {
	while (scanf("%d", &n) != EOF) {
		if (n == 0)break;
		init(n);
		int time = n*(n - 1) / 2;
		int u, v, w; char type;
		int cnt = 0;//有效边的个数
		for (int i = 1; i <= time; i++) {
			scanf("%d%d%d %c", &u, &v, &w, &type);
			if (type == '1') {//如果已经连通，直接合并
				hebing(u, v);
				continue;
			}
			else {
				e[++cnt].u = u;
				e[cnt].v = v;
				e[cnt].w = w;
			}
		}
		sort(e + 1, e + 1 + cnt, cmp);
		int ans = 0;
		for (int i = 1; i <= cnt; i++) {
			if (hebing(e[i].u, e[i].v)) {
				ans += e[i].w;
			}
		}
		cout << ans << endl;
	}
	return 0;
}