最小生成树入门（01/31）

最小生成树

最小生成树是一棵没有回路的树，n个顶点一定有n-1条边，同时也是一个包含全部顶点的生成树。最小生成树就是给定一张边带权的无向联通图G=(V,E),n=|V|,m=|E|。由V中全部顶点和E中n-1条边构成的无向联通子图被称为G的一棵生成树。边的权值之和最小的生成树被称为无向图G的最小生成树（MST）。
最小生成树中有用到贪心的思想，也就是在选择边的时候，每一步都要是最好的（即权重最小的边）边，并且只能用图中的边，也只能刚好用n-1条边。

这里介绍几个最小生成树的基本算法

Kruskal算法

kruskal算法就是在找最小生成树结点之前，需要对边权重从小到大进行排序。将排序好的权重边一次加入带最小生成树中（如果形成回路就continue），当加入的边数为n-1条后，即为这个连通图的最小生成树。

这里在排序的顶端也就是v1开始，选择权重最小的边也就是v1-v4这一条边，同样往下选择了v6-v7、v3-v4、v1-v2这几条边。由于v2-v4、v1-v3这两条边加入会使之前的边形成回路，所以跳过不选，选择v4-v7、v5-v7这两条边。这样刚好6条边（也就是n-1条边），这样我们的最小生成树就构建好了。
当然为了查找边是否会成为回路，这里用到了并查集进行访问。

#include<stdio.h>
#include<algorithm>
#include<iostream>
const int maxn=100;
int n,m,f[maxn];
using namespace std;
int get(int x){
	return x==f[x]?x:f[x]=get(f[x]);//查询元素属于哪个集合
}
void merge(int x,int y){
	f[get(x)]=get(y);//合并两个集合
};
struct Edge{
	int u,v,w;
	bool operator <(const Edge &r)const{//使排序从小到大
	     return w<r.w;
	}
}aa[maxn*maxn];
void kurskal(int n,int m){
	int res=0;
	int num=0;
	sort(aa+1,aa+1+m);
	for(int i=1;i<=m;i++)f[i]=i;//并查集初始化
	for(int i=1;i<=m;i++){
		int f1=get(aa[i].u);
		int f2=get(aa[i].v);
		if(f1!=f2){
			num++;
			res+=aa[i].w;
			merge(f1,f2);
		}
		if(num==n-1)break;//边有n-1条即为生成最小生成树
	}
	if(num==n-1)cout<<res<<endl;//输出最小权重
	else cout<<"?"<<endl;
}
int main(){
	while(~scanf("%d %d",&m,&n)&&m){
		for(int i=1;i<=m;i++)
		cin>>aa[i].u>>aa[i].v>>aa[i].w;
		kurskal(n,m);
	}
	return 0;
}

PRIM算法

PRIM算法就是从任意一个顶点开始生成最小生成树，每次选择一个与当前小树最近的一个顶点，并将其加入到小树中。然后更新这颗小树到其他点的最近距离。
代码转自最小生成树Prim算法理解.

#include<iostream>
#include<fstream>
using  namespace std;
 
#define MAX 100
#define MAXCOST 0x7fffffff
 
int graph[MAX][MAX];
 
int prim(int graph[][MAX], int n)
{
	int lowcost[MAX];
	int mst[MAX];
	int i, j, min, minid, sum = 0;
	for (i = 2; i <= n; i++)
	{
		lowcost[i] = graph[1][i];
		mst[i] = 1;
	}
	mst[1] = 0;
	for (i = 2; i <= n; i++)
	{
		min = MAXCOST;
		minid = 0;
		for (j = 2; j <= n; j++)
		{
			if (lowcost[j] < min && lowcost[j] != 0)
			{
				min = lowcost[j];
				minid = j;
			}
		}
		cout << "V" << mst[minid] << "-V" << minid << "=" << min << endl;
		sum += min;
		lowcost[minid] = 0;
		for (j = 2; j <= n; j++)
		{
			if (graph[minid][j] < lowcost[j])
			{
				lowcost[j] = graph[minid][j];
				mst[j] = minid;
			}
		}
	}
	return sum;
}
 
int main()
{
	int i, j, k, m, n;
	int x, y, cost;
	ifstream in("input.txt");
	in >> m >> n;//m=顶点的个数，n=边的个数
	//初始化图G
	for (i = 1; i <= m; i++)
	{
		for (j = 1; j <= m; j++)
		{
			graph[i][j] = MAXCOST;
		}
	}
	//构建图G
	for (k = 1; k <= n; k++)
	{
		in >> i >> j >> cost;
		graph[i][j] = cost;
		graph[j][i] = cost;
	}
	//求解最小生成树
	cost = prim(graph, m);
	//输出最小权值和
	cout << "最小权值和=" << cost << endl;
	system("pause");
	return 0;
}

辨别最小生成树的唯一性

辨别最小生成树的唯一性，首先要检验是否能生成最小生成树，在生成的同时将每一条边的序号存储起来，在后面进行n-1次循环，每次循环去掉一条边，若生成树且权值等同于最小生成树，则证明最小生成树不唯一。
代码来源最小生成树的唯一性.

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
 
using namespace std;
 
struct edge {
	int begin;
	int end;
	int weight;
};
 
const int maxn = 110;
int father[maxn];
edge e[maxn * maxn];
int map[maxn][maxn];
int n, m;
 
int mst_edge[maxn];
 
int find(int x) {
	if (x == father[x]) {
		return x;
	}
 
	father[x] = find(father[x]);
	return father[x];
}
 
int kruscal(int count) { //使用kruscal算法来生成最小生成树并计算带权路径和
	int i;
	int sum = 0; //用sum来记录最小s生成树的边权和
 
	memset(mst_edge,0,sizeof(mst_edge));
 
	for (i = 1; i < maxn; ++i) {
		father[i] = i;
	}
 
	int k = 0;
	for (i = 1; i <= m && k < n - 1; ++i) { //枚举有序边集中的每一条边
		int fx = find(e[i].begin);
		int fy = find(e[i].end);
 
		if (fx != fy) { //若第k条边的两个端点i,j 分别属于两颗不同的子树
			father[fx] = fy; //则将节点i所在的子树并入节点j所在的子树中
			sum += e[i].weight;
 
			mst_edge[++k] = i;//***用来存储最小生成树中的边的序号
		}
	}
 
	/**
	 * 以下代码是求解最小生成树唯一性问题的核心代码,其算法思想如下:
	 * 在生成的最小生成树的基础上,一次删除每一条边,生成次小生成树,
	 * 然后判断次小生成树的最小边权值是否==最小生成树的最小边权值,
	 * 如果相等,则证明最小生成树不唯一,否则证明所生成的最小生成树唯一
	 *
	 */
	int j;
	for (i = 1; i <= n - 1; ++i) {
		for (k = 1; k < maxn; ++k) {
			father[k] = k;
		}
 
		int ans2 = 0, k2 = 0;
		for (j = 1; j <= m; ++j) {
			if (j == mst_edge[i]) {//模拟删除最小生成树的某一条边
				continue;
			}
 
			int fx = find(e[j].begin);
			int fy = find(e[j].end);
			if (fx != fy) { //若第k条边的两个端点i,j 分别属于两颗不同的子树
				father[fx] = fy; //则将节点i所在的子树并入节点j所在的子树中
				ans2 += e[j].weight;
 
				++k2;
			}
		}
 
		if (k2 != n - 1) {//无法产生生成树
			continue;
		}
 
		if (ans2 == sum) {//最小生成树不唯一
			return -1;
		}
	}
 
	return sum;
}
 
bool compare(const edge& a, const edge& b) {
	return a.weight < b.weight;
}
 
//以上是用kruscal算法来解决问题的基本模板.....
 
int main() {
	int t;
	scanf("%d", &t);
	while (t--) {
		scanf("%d%d", &n, &m);
 
		int i, j;
		for (i = 1; i <= m; ++i) {
			scanf("%d%d%d", &e[i].begin, &e[i].end, &e[i].weight);
		}
		sort(e + 1, e + m + 1, compare); //kruscal算法要求边有序
 
		int sum = kruscal(m);
 
		if(sum == -1){
			printf("Not Unique!\n");
		}else{
			printf("%d\n",sum);
		}
	}
 
	return 0;
}