Kruskal算法模拟讲解

Kruskal 算法是一个求最小生成树的算法，即求最小的开销等

算法可以这样，要求得最小生成树，那么n个节点只能包括n-1条边

所以我们应该转换为寻找这最短的n-1条边，因此，可以先对所有的

边进行从小到大排序，每次取出一条边来进行试探，看是否够成环，

如果不构成环，那么肯定是最短的路径了，因为每次都是取最小

的边来试探，最终可以求得最小的生成树代价和。

/*
	Filename:kruskal.cpp
	Author: xiaobing
	E-mail: xiaobingzhang29@gmail.com
	Date: 2013-08-31
*/
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<cstdlib>
#include<list>
#include<set>
#include<vector>
#define N 100
#define INF 1000000
using namespace std;

/*
 Kruskal 算法是一个求最小生成树的算法，即求最小的开销等
 算法可以这样，要求得最小生成树，那么n个节点只能包括n-1条边
 所以我们应该转换为寻找这最短的n-1条边，因此，可以先对所有的
 边进行从小到大排序，每次取出一条边来进行试探，看是否够成环，
 如果不构成环，那么肯定是最短的路径了，因为每次都是取最小
 的边来试探，最终可以求得最小的生成树代价和。
	用到的数据结构：
		struct edge 表示一条边，包括两个端点及其代价
		edge graph[N] 表示有N条边组成的图
		int father[N] 表示每个点的最上层的根节点
	解释：因为这里需要判断是否形成环路，可以这样，每添加一条
	边，看两个点是否在已经添加进去的边的点集中，若对需要添加
	的这条边，发现两个点都在之前的那个集合中，这一定会形成回
	路，所以，这里设置一个数组father[N],起初时，每个值为-1,代
	表每个点的根节点都没有(因为没有添加一条边进去)，当添加一条
	边后，如果他们的根节点不同，则设置大的那个点的父节点为小
	的那个点，如x > y 则 father[x] = y,这样每个点都只有一个根，
	或者没有根，为-1,所以对添加进的节点，都可以查出他的根，然后
	做比较，都相同，说明已位于添加进的节点中了，否则把该边添加
	进去。

 */

//定义一条边
struct edge{
	int u;		//起始点
	int v;		//目的点
	int cost;	//两点之间的代价
};

//这是一个对块数排序算法调用的一个比较函数
bool cmp(const edge &a, const edge &b){
	return a.cost < b.cost;
}

//查找一个节点的根节点
int findFather(int father[], int x){
	//如果他的父节点不为-1,则应该递归，直到找到其父节点
	if(father[x] != -1){
		//将沿途的所有节点都指向同一个根节点
		return father[x] = findFather(father, father[x]);
	}

	//若为-1,则该点就是根
	return x;
}

//添加一条边
bool unionEdge(int father[], int x, int y){
	//找到一条边的两个端点的根节点
	x = findFather(father, x);
	y = findFather(father, y);

	//根节点相同，说明已经加入了，再加入该边
	//则会形成回路，该边舍弃，返回fasle
	if(x == y){
		return false;
	}

	//若不同，让大的节点的根节点指向小的节点
	if(x > y)	father[x] = y;
	if(x < y)	father[y] = x;

	//该边可以加入，返回true
	return true;
}

int main(){
	edge graph[N];		//定义了一个包含N条边的图
	int father[N];		//定义了一个包含N个节点的根节点
	int i,j, n;	//n代表节点数
	cin>>n;
	//初始化数组
	memset(graph, 0, sizeof(graph));
	//初始化为-1表示任何点都没有父节点，即没有一条边已加入
	memset(father, -1, sizeof(father));

	int k = 0, cost, temp;

	//接收数据
	for(i = 0;i < n;i++)
		for(j = 0;j < n;j++){
			if(i > j){
				graph[k].u = i;
				graph[k].v = j;
				cin>>cost;
				//对于小于0的值，表示不可达，所以代价为无穷大INF
				if(cost < 0){
					graph[k].cost = INF;
				} else {
					graph[k].cost = cost;
				}
				k++;
				continue;
			}
			//由于是对称的，该值无用，但得接收
			cin>>temp;
		}

	//将所有边从小到大排序
	sort(graph, graph + k, cmp);

	//打印排序后的边
	for(i = 0;i < k;i++){
		cout<<i<<" "<<graph[i].u<<"->"<<graph[i].v<<": "<<graph[i].cost<<endl;
	}

	//count为记录已经加入的边数，到n-1时截止
	//sum为最小生成树的代价和
	int count = 0, sum = 0;

	//从小到大遍历k条边
	for(i = 0; i < k;i++){
		//探测该边是否可加入
		if(unionEdge(father, graph[i].u, graph[i].v)){
			count++;
			sum += graph[i].cost;
		}

		//当加入n-1条边时，已满足连通图，则退出
		if(count == n - 1)	break;
	}

	cout<<"最小生成树代价和sum : "<<sum<<endl;

    return 0;
}

测试例子：

7
0 5 -1 -1 -1 11 2
5 0 10 8 -1 -1 13
-1 10 0 7 -1 -1 -1
-1 8 7 0 12 9 4
-1 -1 -1 12 0 10 -1
11 -1 -1 9 10 0 3
2 13 -1 4 -1 3 0

结果：

0 6->0: 2
1 6->5: 3
2 6->3: 4
3 1->0: 5
4 3->2: 7
5 3->1: 8
6 5->3: 9
7 2->1: 10
8 5->4: 10
9 5->0: 11
10 4->3: 12
11 6->1: 13
12 2->0: 1000000
13 6->4: 1000000
14 6->2: 1000000
15 3->0: 1000000
16 5->2: 1000000
17 5->1: 1000000
18 4->2: 1000000
19 4->1: 1000000
20 4->0: 1000000
最小生成树代价和sum : 31