poj1789-Truck History（最小生成树）

大致题意：

有一些货车，每个货车可以用一个长度为7的字符串表示，货车之间的距离为两个字符串之间相异字符的个数。除去初始字符串，要将每个字符串由其它字符串推导出来，推导的代价为两个字符串之间的距离。求整个推导过程的最小代价。

解题思路：

将货车看成结点，货车之间的距离看成边。该问题是一个求最小生成树的问题。可以使用Kruskal算法和Prim算法解决。

方法一（Kruskal算法）：

//Memory  Time
//45584K  1391MS
#include <iostream>
#include <cstdlib>
using namespace std;

struct node{ //并查集中的结点
	int num; //结点的编号
	int rank; //结点的秩
	node *parent; //指向父结点的指针
};

void make_set(node *x){ //构造一个并查集
	x->parent = x;
	x->rank = 0;
}

node* find_set(node *x){ //查
	if(x != x->parent)
		x->parent = find_set(x->parent);
	return x->parent;
}

void link(node *x, node *y){
	if(x->rank > y->rank)
		y->parent = x;
	else
		x->parent = y;
	if(x->rank == y->rank)
		y->rank = y->rank + 1;
}
		
void union_two_sets(node *x, node *y){ //并
	link(find_set(x), find_set(y));
}

int distance(char a[], char b[]){ //求两个truck type的距离
	int num = 0;
	for(int i = 0; i < 7; i++){
		if(a[i] != b[i])
			num++;
	}
	return num;
}

struct edge{
	int num1;
	int num2;
	int weight;
};

int compare(const void *p1, const void *p2){
	return ((edge*)p1)->weight - ((edge*)p2)->weight;
}

const int MAX = 2002;
char truck[MAX][8];
edge edges[MAX*MAX];
node nodes[MAX];

int main()
{
	int n;
	while(cin >> n && n != 0){
		for(int i = 0; i < n; i++)
			cin >> truck[i];
		int edge_num = 0; //边的条数
		for(int i = 0; i < n; i++){
			for(int j = 0; j < n; j++){
				if(j == i)
					continue;
				edges[edge_num].num1 = i;
				edges[edge_num].num2 = j;
				edges[edge_num].weight = distance(truck[i], truck[j]);
				edge_num++;
			}
		}
		qsort(edges, edge_num, sizeof(edge), compare);
		for(int i = 0; i < n; i++){
			nodes[i].num = i;
			make_set(&nodes[i]);
		}
		int result = 0;
		for(int i = 0; i < edge_num; i++){
			if(find_set(&nodes[edges[i].num1]) != find_set(&nodes[edges[i].num2])){
				result += edges[i].weight;
				union_two_sets(&nodes[edges[i].num1], &nodes[edges[i].num2]);
			}
		}
		cout << "The highest possible quality is 1/" << result << "." << endl;
	}
	return 0;
}

方法二（Prim算法）：

//Memory  Time
//15668K  704MS
#include <iostream>
using namespace std;

const int MAX = 2002; //最多顶点个数
int N; //实际顶点个数
int dis[MAX][MAX]; //顶点之间的距离
int key[MAX]; //key[v]是将顶点v与最小生成树中某一顶点相连的边中的最小权值
int visited[MAX]; //标记是否被访问
char truck[MAX][8];

int distance(char a[], char b[]){ //求两个truck type的距离
	int num = 0;
	for(int i = 0; i < 7; i++){
		if(a[i] != b[i])
			num++;
	}
	return num;
}

int prim(){
	int result = 0;
	for(int i = 0; i < N; i++){
		key[i] = 0x7FFFFFFF;
		visited[i] = 0;
	}
	key[0] = 0;
	for(int i = 0; i < N; i++){
		int min_index = -1;
		int min = 0x7FFFFFFF;
		for(int j = 0; j < N; j++){
			if(visited[j] == 0 && key[j] < min){
				min_index = j;
				min = key[min_index];
			}
		}
		visited[min_index] = 1;
		result += key[min_index];
		for(int j = 0; j < N; j++){
			if(visited[j] == 0 && dis[j][min_index] < key[j]){
				key[j] = dis[j][min_index];
			}
		}
	}
	return result;
}

int main(){
	while(cin >> N && N != 0){
		for(int i = 0; i < N; i++)
			cin >> truck[i];
		for(int i = 0; i < N; i++){
			for(int j = i+1; j < N; j++){
				int d = distance(truck[i], truck[j]);
				dis[i][j] = d;
				dis[j][i] = d;
			}
		}
		cout << "The highest possible quality is 1/" << prim() << "." << endl;
	}
	return 0;
}