最小生成树算法——Prim算法和Kruskal算法

Prim算法

该算法是一颗小树逐渐变大的过程。每次找到距树距离最小的点，最后加起来的权值就会最小（贪心）。
设V是图中所有点构成的集合，U是生成树的点构成的集合，lowcost[j]表示结点j到生成树的最小距离（即与生成树中所有距离的最小值）。其步骤如下:

1. 确定数据结构。
   用邻接矩阵e[i][j]表示有权图，如果i,j之间存在边，则e[i][j]为 边权值；否则为无穷大INF。

   用bool数组book[i]表示顶点i是否已经加入了U。若加入了book[i]=true；否则为false（即在V-U中）。

2. 初始化。
   因为最后所有的点都会加入U，所以不妨初始化时任取一点加入U。笔者习惯将1加入，即book[1]=1。

   更新lowcost数组。这一步是基于上一步的。上一步实际上是将结点1作为了一棵树，那么V-U中点到这棵树的距离相当于是V-U中点到初始点即1的距离。故lowcost[i]=e[1][i]。

3. 在V-U中找到lowcost最小的点k，即找到距树距离最小的点。若找不到，算法结束。

4. 将k加入U。

5. 如果最小树已生成，算法结束，否则，转步骤6。

6. 对V-U中的所有顶点j，更新其lowcost[j]。由于生成树加入了一个顶点j，那么就要判断lowcost[j]是否要更新，即是原来的lowcost[j]小，还是e[t][j]小，lowcost[j]=min{lowcost[j],e[t][j]}。转步骤3。

代码如下:

#include <stdio.h>
#define INF 0x3f3f3f3f
int n, m;//顶点数和边数
int e[100][100], book[100], lowcost[100];
void Prim()
{
	int i, j;
	int ans = 0;//记录答案
	//初始化
	book[1] = 1;//任取顶点构成初始生成树
	for(i = 1; i <= n; i++) lowcost[i] = e[1][i];
	//开始生成最小生成树
	for(i = 1; i < n; i++)//加入n-1个顶点，执行n-1次操作
	{
		int MIN = INF;
		int k = -1;
		for(j = 1; j <= n; j++)//找到距树最短的顶点
			if(!book[j] && MIN>lowcost[j])
			{
				k = j;
				MIN = lowcost[j];
			}
		if(k == -1) break;//如果找不到，说明V-U中所有的点到树没有边了，即整个图是不连通的，那么算法结束
		ans += MIN;
		book[k] = 1;//将该顶点加入U
		//树中加入了一个顶点，那么所有V-U中的lowcost[j]都要判断是否改变
		for(j = 1; j <= n; j++)
			if(!book[j] && lowcost[j]>e[k][j])
				lowcost[j] = e[k][j];
	}
	if(i == n) printf("%d\n", ans);//加入了n-1个顶点
	else printf("No MST exists!\n");
} 
int main()
{
	scanf("%d%d", &n, &m);
	int i, j;
	for(i = 1; i <= n; i++)
	{
		e[i][i] = 0;
		for(j = i+1; j <= n; j++)
			e[i][j] = e[j][i] = INF;
	}
	//输入m条边
	for(i = 1; i <= m; i++)
	{
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);
		e[a][b] = e[b][a] = c;
	}
	Prim();
	return 0; 
}

Kruskal算法

该算法是将森林合并成树的过程。每次将权值最小的边加入边集，最后加起来的权值就会最小（贪心）。
其步骤如下:

1. 将所有权值排序。这里用到C++的sort函数
2. 从小到大判断边是否可以加入边集，需要判断是否构成环，因为树本身是一种无环图。这里用到并查集。
3. 由树的性质：|E|=|V|-1。那么如果已经加入了n-1条边，则算法结束；否则，最小生成树不存在。

代码如下:

#include <iostream>
#include <algorithm>
using namespace std;
//用结构体存储每条边
struct node 
{
	int u, v, w;
}e[100];
int father[100], n, m;
bool cmp(struct node a, struct node b)
{
	return a.w < b.w;
}
int Find(int x)
{
	if(father[x]! = x) father[x] = Find(father[x]);
	return father[x];
}
bool Merge(int a, int b)
{
	int r1 = Find(a);
	int r2 = Find(b);
	if(r1 != r2) 
	{
		if(r1 < r2) father[r2] = r1;
		else father[r1]=r2;
		return 1;
	}//将编号大的加入编号小的集合
	return 0;
}
void Kruskal()
{
	int i;
	for(i = 1 ;i <= n; i++) father[i] = i;
	int ans = 0;
	int cnt = 0;//记录加入了几条边
	for(i = 1; i <= m; i++)
	{
		if(Merge(e[i].u, e[i].v))
		{
			ans + =e[i].w;
			cnt++;
			if(cnt == n-1) break;
		}
	}
	if(cnt == n-1) cout << ans << endl;
	else cout << "No MST exists!" << endl;
}
int main()
{
	cin>> n >> m;
	int i;
	for(i = 1; i <= m; i++)
		cin>> e[i].u >> e[i].v >> e[i].w;
	sort(e+1, e+1+m, cmp);
	Kruskal();
	return 0;	
}

个人感觉Kruskal好理解一点，所以就写的简单一点。。。