最小生成树 - Kruskal算法

Kruskal算法步骤如下：

 

1. 新建图G，G中拥有原图中相同的节点，但没有边

2. 将原图中所有的边按权值从小到大排序

3. 从权值最小的边开始，如果这条边连接的两个节点于图G中不在同一个连通分量中，则添加这条边到图G中

4. 重复3，直至图G中所有的节点都在同一个连通分量中

 

Kruskal算法的实现类似于计算连通支的算法。它使用了分离集合数据结构以保持数个互相分离的元素集合。每一集合包含当前森林中某个树的结点，操作FIND-SET(u)返回包含u的集合的一个代表元素，因此我们可以通过FIND-SET(v)来确定两结点u和v是否属于同一棵树，通过操作UNION来完成树与树的联结。

伪代码如下：

 

 

MST-KRUSKAL(G,w)
1. A←Æ
2. for 每个结点v V[G] 
3.   do MAKE-SET(v)
4. 根据权w的非递减顺序对E的边进行排序
5. for 每条边(u,v)ÎE，按权的非递减次序
6.   do if FIND-SET(u) ≠ FIND-SET(v)
7.        then A←A∪{(u,v)}
8.             UNION(u,v)
9  return A 

我们使用并查集来实现Kruskal算法，C++代码如下：

#include <stdio.h>
#include <memory.h>
#include <algorithm>
using namespace std;
#define N 10000
struct Edge
{
	int u,v,w;
};
class UFset
{
private:
	bool *root;
	int *parent;
	int n;
public:
	UFset(int n)
	{
		int i; this->n=n;
		root=new bool[n];
		parent=new int[n];
		for(i=0;i<n;i++)
		{
			parent[i]=1;  root[i]=true;
		}
	}
	~UFset()
	{
		delete []parent;
		delete []root;
	}

	int Find(int e)
	{
		// Return root of tree containing e.
		// Compact path from e to root.
		int i=e;
		// Find root
		while(!root[i]) i=parent[i];
		// compact path
		int j=e;// start at e
		while(j!=i)// j is not root
		{
			int pj=parent[j];
			parent[j]=i;// move j to level 2
			j=pj;// j moves to old parent 
		}
		return i;
	}

	bool Union(int x,int y)
	{
		// Combine trees with roots px and py.
		int px=Find(x);
		int py=Find(y);
		if(px==py)  return false;
		if(parent[px]<parent[py])
		{
			// px becomes subtree of py
			parent[py]+=parent[px];
			root[px]=false;
			parent[px]=py;
		}
		else
		{
			// py becomes subtree of px
			parent[px]+=parent[py];
			root[py]=false;
			parent[py]=px;
		}
		return true;
	}
};

class graph
{
public:
	int n,m;       Edge edge[N];     void kruskal();
};
bool cmp(const Edge &e1,const Edge &e2)
{
	return e1.w<e2.w;
}
void graph::kruskal()
{
	sort(edge,edge+m,cmp);
	UFset ufset(n); 
	int min=0,k=0;
	for(int i=0;i<m;i++)
	{
		if(ufset.Union(edge[i].u,edge[i].v))
		{
			min+=edge[i].w;       ++k;
		}
		if(k==n-1)  break;
	}
	printf("%d/n",min);
}

graph g;
int main()
{
	int i,j,w;
	while(scanf("%d",&g.n)!=EOF)
	{
		int k=0;
		for(i=0;i<g.n;i++)
		{
			for(j=0;j<g.n;j++)
			{
				scanf("%d",&w);
				if(i<j)
				{
					g.edge[k].u=i;  g.edge[k].v=j;
					g.edge[k].w=w;  k++;
				}
			}
		} 
		g.m=k;        g.kruskal();
	}
	return 0;
}