【模板】最小生成树（MST）（连接计算机、还是畅通工程题解）

算法流程

1.使用结构数组存储所有的边的信息。

2.对所有边按照边的权值进行从小到大排序。

3.根据Kruskal算法，来自不同的分支，找到尽可能小权值的边将其联通起来。也就是说，排序后遍历每一条边，如果这条边的两个结点来自不同分支（采用并查集方式来记录同一分支），则可以使用这条边将两个分支联通。

注意点

1. 并查集记录该节点分支的根时，要注意优化findRoot()函数。

2. 使用结构体记录每一条边，按照边的权值排序。

3. 合并时遍历所有的边，但实际上MST只会有n-1条边。

4. 合并时注意是对分支的根合并。

连接计算机

描述

教学楼有n台计算机，为了方便数据传输，现要将它们用数据线连接起来。两台计算机被连接是指它们有数据线连接。由于计算机所处的位置不同，因此不同的两台计算机的连接费用往往是不同的。

当然，如果将任意两台计算机都用数据线连接，费用将是相当庞大的。为了节省费用，我们采用数据的间接传输手段，即一台计算机可以间接的通过若干台计算机（作为中转）来实现与另一台计算机的连接。

现在由你负责连接这些计算机，任务是使任意两台计算机都连通（不管是直接的或间接的）。

输入

费用以矩阵的形式给出,代表连接第i台与第j台计算机的费用。 
第一行为整数n（2≤n≤100），表示计算机的数目。此后的n行，每行n个整数。

输出

一个整数，表示最小的连接费用。

样例

输入

3 
0 1 2 
1 0 1 
2 1 0 

输出

2

#include<iostream>
#include<algorithm>
using namespace std;
 int map[110][110];
 int Tree[110];
 struct E{
	int a,b;
	int cost;
	bool operator < (const E &a) const
	{
		return cost<a.cost;
	 } 
};
E edges[6000]; 
int findRoot(int x)
{
	if(Tree[x]==-1) return x;
	else{
		int temp = findRoot(Tree[x]);
		Tree[x] = temp;
		return temp;
	}
 }
 int main(void)
 {
 	int n;int count=0; 
 	scanf("%d",&n);
 	for(int i=1;i<=n;i++){
 		for(int j=1;j<=n;j++){
 			scanf("%d",&map[i][j]);
		 }
	 }
	 for(int i=1;i<=n;i++){
	 	for(int j=i+1;j<=n;j++){
	 		E tmp;
	 		tmp.a=i;tmp.b=j;
	 		tmp.cost=map[i][j];
	 		edges[count]=tmp;
	 		count++;
		 }
	 }
	 sort(edges,edges+count);
	 for(int i=1;i<=n;i++) Tree[i]=-1;
	 int ans=0;
	 for(int i=0;i<count;i++){
	 	int x = edges[i].a;
	 	int y = edges[i].b;
	 	int c = edges[i].cost;
	 	x = findRoot(x);
	 	y = findRoot(y);
	 	if(x!=y){
	 		ans+=c;
	 		Tree[x]=y;
		 }
	 }
	 printf("%d\n",ans);
	 return 0;
  } 

还是畅通工程 

题目描述

某省调查乡村交通状况，得到的统计表中列出了任意两村庄间的距离。省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可），并要求铺设的公路总长度为最小。请计算最小的公路总长度。

输入描述

测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N ( < 100 )；随后的N(N-1)/2行对应村庄间的距离，每行给出一对正整数，分别是两个村庄的编号，以及此两村庄间的距离。为简单起见，村庄从1到N编号。
当N为0时，输入结束，该用例不被处理。

输出描述

对每个测试用例，在1行里输出最小的公路总长度。

输入

3
1 2 1
1 3 2
2 3 4
4
1 2 1
1 3 4
1 4 1
2 3 3
2 4 2
3 4 5
0

输出

3
5

#include<iostream>
#include<cstring>
#include<algorithm>
#define N 6001
using namespace std; 
int Tree[101];
struct E{
	int A,B;
	int cost;
	bool operator < (const E &e) const{
		return cost<e.cost;
	}
};
int findRoot(int x){
	if(Tree[x]==-1) return x;
	else return findRoot(Tree[x]);
}
E edge[6001];
int main(void){
	int n,m;
	while(cin>>n){
		if(n==0) break;
		for(int i=1;i<=n*(n-1)/2;i++){
			cin>>edge[i].A>>edge[i].B>>edge[i].cost;
		}
		for(int i=1;i<=n;i++){
			Tree[i]=-1;
		}
		sort(edge+1,edge+1+n*(n-1)/2);//排序所有的边 
		int sum=0;
		for(int i=1;i<=n*(n-1)/2;i++){
			int na = edge[i].A;
			int nb = edge[i].B;
			int c = edge[i].cost;
			na = findRoot(na);
			nb = findRoot(nb);//利用并查集来记录它们是否在一个分支 
			if(na!=nb){
				Tree[na]=nb;//没有在同一个分支则合并 
				sum += c;
			}
		}
		cout<<sum<<endl;
	}
	return 0;
}