最小生成树算法

本文转载自：原文地址

普利姆（Prime）算法（只与顶点相关）

 

算法描述：

普利姆算法求最小生成树时候，和边数无关，只和定点的数量相关，所以适合求稠密网的最小生成树，时间复杂度为O（n*n）。

算法过程：

1.将一个图的顶点分为两部分，一部分是最小生成树中的结点（A集合），另一部分是未处理的结点（B集合）。

2.首先选择一个结点，将这个结点加入A中，然后，对集合A中的顶点遍历，找出A中顶点关联的边权值最小的那个（设为v），将此顶点从B中删除，加入集合A中。

3.递归重复步骤2，直到B集合中的结点为空，结束此过程。

4.A集合中的结点就是由Prime算法得到的最小生成树的结点，依照步骤2的结点连接这些顶点，得到的就是这个图的最小生成树。

算法实现具体过程：

1.将第一个点放入最小生成树的集合中（标记visit[i]=1意思就是最小生成树集合）。

2.从第二个点开始，初始化lowcost[i]为跟1点相连（仅仅相连）的边的权值（lowcost[i]不是这个点的最小权值！在以后会逐步更新）。

3.找最小权值的边。

从第二点开始遍历，如果不是最小生成树的集合的点，则找出从2到n的最小权值（lowcost[j]）。

4.将找出来的最小权值的边的顶点加入最小生成树的集合中（标记visit[i] = 1），权值想加。

5.更新lowcost[j]集合。

假设第一次：lowcost[2]代表与1相连的点的权值，现在加入了k点。则比较k点与2点的边map[k][2]和lowcost[2]的大小，若lowcost[2]大，则lowcost[2] = map[k][2]。（关键步骤：实质就是每在最小生成树集合中加入一个点就需要把这个点与集合外的点比较，不断的寻找两个集合之间最小的边）

6.循环上述步骤，指导将全部顶点加入到最小生成树集合为止。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

#define INF 1000000000
#define MAXN 110

int map[MAXN][MAXN];  // map[i][j] 表示 i j 两个点的权值 
int lowcost[MAXN];  // lowcost[i]表示 i 与当前扩展节点之间的权值。

bool visited[MAXN]; //visited[i]表示 i 为最小生成树中的点。


int Prime (int n){
	int tmp,sum=0,k;
	memset (visited,false,sizeof (visited));  //初始化visited[] 为0 。
	visited[1] = true; //假设从节点1开始。
	
	for (int i=1;i<=n;i++)  //所有点与1节点之间的权值
		lowcost[i] = map[1][i];   

	for (int i=1;i<=n;i++){  //遍历图中的所有节点。
		tmp = INF;
		for (int j = 1;j <= n;j++)
			if (!visited[j] && lowcost[j] < tmp)
				tmp = lowcost[k=j];  //找出当前扩展节点与其余未访问节点的最小权值。更新当前扩展节点
		if (tmp == INF) break;
		visited[k] = true; //加入最小生成树的集合。
		sum += tmp; //累加权值、

		for (int i=1;i <= n;i++) //更新lowcost[].
			if (!visited[i] && map[k][i] < lowcost[i])
				lowcost[i] = map[k][i];
	}
	return sum;
}
int main(){
	int a,b,n,cost,edge;
	while (cin>>n && n){
		memset (map,INF,sizeof (map));
		edge = n * (n-1) / 2;
		for (int i=1; i<= edge;++i){
			cin >> a >> b >> cost;
			if (cost < map[a][b])
				map[a][b] = map[b][a] = cost;
		}
		cout << Prime (n)<<endl;
	}
	return 0;
}

克鲁斯卡尔（Kruskal）算法（只与边相关）


算法描述：克鲁斯卡尔算法需要对图的边进行访问，所以克鲁斯卡尔算法的时间复杂度只和边又关系，可以证明其时间复杂度为O（eloge）。
算法过程：
1.将图各边按照权值进行排序
2.将图遍历一次，找出权值最小的边，（条件：此次找出的边不能和已加入最小生成树集合的边构成环），若符合条件，则加入最小生成树的集合中。不符合条件则继续遍历图，寻找下一个最小权值的边。
3.递归重复步骤1，直到找出n-1条边为止（设图有n个结点，则最小生成树的边数应为n-1条），算法结束。得到的就是此图的最小生成树。


克鲁斯卡尔（Kruskal）算法因为只与边相关，则适合求稀疏图的最小生成树。而prime算法因为只与顶点有关，所以适合求稠密图的最小生成树。


代码如下：

#include<iostream>
#include<cstring>
#include<string>
#include<cstdio>
#include<algorithm>
using namespace std;
#define MAX 1000
int father[MAX], son[MAX];
int v, l;

typedef struct Kruskal //存储边的信息
{
	int a;
	int b;
	int value;
};

bool cmp(const Kruskal & a, const Kruskal & b)
{
	return a.value < b.value;
}

int unionsearch(int x) //查找根结点+路径压缩
{
	return x == father[x] ? x : unionsearch(father[x]);
}

bool join(int x, int y) //合并
{
	int root1, root2;
	root1 = unionsearch(x);
	root2 = unionsearch(y);
	if(root1 == root2) //为环
		return false;
	else if(son[root1] >= son[root2])
		{
			father[root2] = root1;
			son[root1] += son[root2];
		}
		else
		{
			father[root1] = root2;
			son[root2] += son[root1];
		}
	return true;
}

int main()
{
	int ncase, ltotal, sum, flag;
	Kruskal edge[MAX];
	scanf("%d", &ncase);
	while(ncase--)
	{
		scanf("%d%d", &v, &l);
		ltotal = 0, sum = 0, flag = 0;
		for(int i = 1; i <= v; ++i) //初始化
		{
			father[i] = i;
			son[i] = 1;
		}
		for(int i = 1; i <= l ; ++i)
		{
			scanf("%d%d%d", &edge[i].a, &edge[i].b, &edge[i].value);
		}
		sort(edge + 1, edge + 1 + l, cmp); //按权值由小到大排序
		for(int i = 1; i <= l; ++i)
		{
			if(join(edge[i].a, edge[i].b))
			{
				ltotal++; //边数加1
				sum += edge[i].value; //记录权值之和
				cout<<edge[i].a<<"->"<<edge[i].b<<endl;
			}
			if(ltotal == v - 1) //最小生成树条件：边数=顶点数-1
			{
				flag = 1;
				break;
			}
		}
		if(flag) printf("%d\n", sum);
		else printf("data error.\n");
	}
	return 0;
}