Constructing Roads

题目描述：

There are N villages, which are numbered from 1 to N, and you should build some roads such that every two villages can connect to each other. We say two village A and B are connected, if and only if there is a road between A and B, or there exists a village C such that there is a road between A and C, and C and B are connected.

We know that there are already some roads between some villages and your job is the build some roads such that all the villages are connect and the length of all the roads built is minimum.

输入：

The first line is an integer N (3 <= N <= 100), which is the number of villages. Then come N lines, the i-th of which contains N integers, and the j-th of these N integers is the distance (the distance should be an integer within [1, 1000]) between village i and village j.

Then there is an integer Q (0 <= Q <= N * (N + 1) / 2). Then come Q lines, each line contains two integers a and b (1 <= a < b <= N), which means the road between village a and village b has been built.

输出：

You should output a line contains an integer, which is the length of all the roads to be built such that all the villages are connected, and this value is minimum.

样例输入：

3
0 990 692
990 0 179
692 179 0
1
1 2

样例输出：

179

一个最小生成树问题，可以使用Prim和Kruska

Prim算法简述

1).输入：一个加权连通图，其中顶点集合为V，边集合为E；
2).初始化：Vnew= {x}，其中x为集合V中的任一节点（起始点），Enew= {},为空；
3).重复下列操作，直到Vnew= V：
a.在集合E中选取权值最小的边<u, v>，其中u为集合Vnew中的元素，而v不在Vnew集合当中，并且v∈V（如果存在有多条满足前述条件即具有相同权值的边，则可任意选取其中之一）；
b.将v加入集合Vnew中，将<u, v>边加入集合Enew中；
4).输出：使用集合Vnew和Enew来描述所得到的最小生成树。 [1]

Kruskal算法简述

假设 WN=(V,{E}) 是一个含有 n 个顶点的连通网，则按照克鲁斯卡尔算法构造最小生成树的过程为：先构造一个只含 n 个顶点，而边集为空的子图，若将该子图中各个顶点看成是各棵树上的根结点，则它是一个含有 n 棵树的一个森林。之后，从网的边集 E 中选取一条权值最小的边，若该条边的两个顶点分属不同的树，则将其加入子图，也就是说，将这两个顶点分别所在的两棵树合成一棵树；反之，若该条边的两个顶点已落在同一棵树上，则不可取，而应该取下一条权值最小的边再试之。依次类推，直至森林中只有一棵树，也即子图中含有 n-1条边为止。

可以根据个人喜好使用，当然啦，我个人比较喜欢用第二个

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<math.h>
using namespace std;
int father[10005];
void init(int x)
{
	for(int i=1;i<=x;i++)
	{
		father[i]=i;
	}
}
int findd(int a)
{
	if(father[a]==a)return a;
	else return father[a]=findd(father[a]);
}
void unit(int a,int b)
{
	int x=findd(a);
	int y=findd(b);
	if(x!=y)
	{
		father[x]=y;
	}
}
struct node{
	int u,v,cost;
}feng[10005];
bool cmp(node a,node b)
{
	return a.cost<b.cost;
}
int main()
{
	int t,m;
	while(~scanf("%d",&m)&&m)
	{
		for(int i=0;i<m;i++)
		{
			for(int j=0;j<m;j++)
			{
				feng[i*m+j].u=i+1;
				feng[i*m+j].v=j+1; 
				scanf("%d",&feng[i*m+j].cost);
			}
		}
		init(m+5);
		sort(feng,feng+m*m,cmp);
		int n=m*m;
		long long res=0;
		int cnt=0;
		scanf("%d",&t);
		while(t--)
		{
			int aa,bb;
			scanf("%d%d",&aa,&bb);
			unit(aa,bb);
		}
		for(int i=0;i<n;i++)
		{
			if(cnt==m-1)
			{
				break;
			}
			int xx=findd(feng[i].u);
			int yy=findd(feng[i].v);
			if(xx!=yy)
			{
				unit(feng[i].u,feng[i].v);
				res+=feng[i].cost;
				cnt++;
			}
		}
		printf("%lld\n",res);
	}
	return 0;
}

整体代码可能略显累赘，额，毕竟是从其他题目里改过来的，当然，模板的感觉也更浓重一些