1789 Truck History【最小生成树】

Truck History



Time
 Limit: 2000MS
 
Memory Limit: 65536K


Total Submissions: 21660
 
Accepted: 8419






Description
Advanced Cargo Movement, Ltd. uses trucks of different types. Some trucks are used for vegetable delivery, other for furniture, or for bricks. The company has its own code describing each type of a truck. The code is simply a string of exactly seven lowercase letters (each letter on each position has a very special meaning but that is unimportant for this task). At the beginning of company‘s history, just a single truck type was used but later other types were derived from it, then from the new types another types were derived, and so on. 

Today, ACM is rich enough to pay historians to study its history. One thing historians tried to find out is so called derivation plan -- i.e. how the truck types were derived. They defined the distance of truck types as the number of positions with different letters in truck type codes. They also assumed that each truck type was derived from exactly one other truck type (except for the first truck type which was not derived from any other type). The quality of a derivation plan was then defined as 
1/Σ(to,td)d(to,td)
where the sum goes over all pairs of types in the derivation plan such that to is the original type and td the type derived from it and d(to,td) is the distance of the types. 
Since historians failed, you are to write a program to help them. Given the codes of truck types, your program should find the highest possible quality of a derivation plan. 


Input
The input consists of several test cases. Each test case begins with a line containing the number of truck types, N, 2 <= N <= 2 000. Each of the following N lines of input contains one truck type code (a string of seven lowercase letters). You may assume that the codes uniquely describe the trucks, i.e., no two of these N lines are the same. The input is terminated with zero at the place of number of truck types.

Output
For each test case, your program should output the text "The highest possible quality is 1/Q.", where 1/Q is the quality of the best derivation plan.

Sample Input
4
aaaaaaa
baaaaaa
abaaaaa
aabaaaa
0

Sample Output
The highest possible quality is 1/3.

题意：

每个卡车的车牌号都由七个字母表示，而且唯一，两个车牌号对应位置有多少个字符不一样，那么这两个车牌号的差别度为几，现在给出若干个车牌号，让你把他们连接在一起，可以直接连，或者间接连接，使得他们中直接相连的车牌号之间的差异度的和最小，求出这个最小值，Q，然后按要求输出.......

分析：

这个题，题意不太好理解，但是如果理解了题意之后，并不算复杂，可以很容易发现这是个图论里的最小生成树的模版题目，只是需要加条件转化一下为常见的模板题目，这道题的边数比较多，适合用prim算法，不过我这里使用的克鲁斯克尔算法，因为这个做法的人比较少，大概讲一下自己的思路，

   首先定义一个结构体来保存顶点和边，然后是并查集的初始化，查找，合并函数，以及排序函数，另外一个比较函数在遍历的时候求出每两个不同的车牌号之间的差异度（权值），下面就是一般的思路了：按边的权值从小到大排序，遍历所有边，如果没有连通，就加入到同一个集合，并且统计总权值，否则不统计，一直到n-1条边（n个元素）连入同一个集合，最小生成树就生成了，用克鲁斯卡尔算法算法注意数组的范围，给出的顶点最大限度是2000以内，那就要考虑2000*1999/2，大约200万条边的范围了，算法不错，注意好按要求输出，这道题就基本上没问题了，具体看代码注释。

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
char trk[2005][15];
int per[2005],cnt,kase,n;
struct scs//结构体保存顶点和边的权值
{
	int a,b;
	int len;
}x[2500005];
void init()//初始化函数
{
	for(int i=1;i<=n;++i)
	{
		per[i]=i;
	}
}
int find(int x)//查找根节点
{
	int r=x;
	while(r!=per[r])
	{
		r=per[r];
	}
	int i=x,j;
	while(i!=r)
	{
		j=per[i];per[i]=r;i=j;
	}
	return r;
}
void join(int x,int y)//合并函数
{
	int fx=find(x),fy=find(y);
	if(fx!=fy)
	{
		per[fy]=fx;
		++cnt;kase=1;//合并成功，边数增加
	}
}
int com(char a[],char b[])//计算差异度（权值）
{
	int i,c=0;
	for(i=0;i<7;++i)
	{
		if(a[i]!=b[i])
		{
			++c;
		}
	}
	return c;
}
bool cmp(scs a,scs b)
{
	return a.len<b.len;
}
int main()
{
	int i,j,c;
	while(scanf("%d",&n),n)
	{
		init();c=cnt=0;
		getchar();
		for(i=0;i<n;++i)
		{
			scanf("%s",trk[i]);//输入保存每一个车牌号
		}
		for(i=0;i<n-1;++i)
		{
			for(j=i+1;j<n;++j)
			{
				if(i!=j)
				{
					x[c].a=i+1;x[c].b=j+1;//保存顶点的编号
					x[c].len=com(trk[i],trk[j]);//计算权值
					++c;
				}
			}
		}
		sort(x,x+c,cmp);int sum=0;
		for(i=0;i<c&&cnt<n-1;++i)
		{
			kase=0;
			join(x[i].a,x[i].b);
			if(kase)//加入集合成功，就累加总权值
			{
				sum+=x[i].len;
			}
		}
		printf("The highest possible quality is 1/%d.\n",sum);//注意按要求输出，
	}
	return 0;
}

版权声明：本文为博主原创文章，未经博主允许不得转载。