克鲁斯卡尔算法、并查集

1. 并查集

看《大话数据结构》中的克鲁斯卡尔算法时一直没能真正理解代码含义，关键是因为没搞懂并查集，直到看了这篇文章。
并查集是一种树型的数据结构，用于处理一些不相交集合的合并及查询问题。对于图中的两个顶点A和B，通过并查集可以判断是否AB之间是否有路径。同时，也可以判断将A和B相连之后是否可以形成环，因为如果AB之间有路径的话，那么再将A和B相连就会出现环。
并查集的基本操作包括：初始化，查找，合并。为了提高查找的效率通常会用到路径压缩。
我们使用数组int parent[maxSize]来存储每个顶点的爸爸（不太严谨，暂时这样叫吧），parent[i]存储的就是顶点i的爸爸，如果顶点i与顶点j的爸爸相同，说明他们在一个集合中，那么他们可以连通。

1.1初始化

初始化时可以将每个顶点的爸爸初始化为他自己，自己是自己的爸爸（。。。）

for(int i = 0; i < N; i++)
	parent[i] = i;

1.2查找

找爸爸，这里找的是爸爸的爸爸的爸爸的。。。直到找到自己是自己爸爸的那个顶点。

int Find(int v) {
	while(parent[v] != v) {
		v = parent[v];
	}
	return v;
}

1.3合并

如果两个顶点没有共同的爸爸，即他们不在同一个树中，则将两者合并到一个树中。

void Union(int s, int e) {
	int sRoot = Find(s);
	int eRoot = Find(e);
	if(sRoot != eRoot) {
		parent[sRoot] = eRoot;//s和e的祖宗不同,将两个树合成一个树,这里假设s的祖宗是e的祖宗的儿砸
	}
}

s和e的祖宗不同,将两个树合成一个树,这里假设s的祖宗是e的祖宗的儿砸，这个假设不一定合适，凭什么s的祖宗辈分低，毕竟现在谁都想当爸爸（手动狗头）。
合并的时候谁当爸爸也是有讲究的，具体1.4路径压缩。

1.4路径压缩

引用这篇博客的例子：

路径压缩是为了方便找到爸爸（老大）。

int Find(int v) {
	int root = v;
	while(parent[root] != root) {
		root = parent[root];//寻找祖先结点
	}
	//将沿途的非祖先结点的爸爸全部变为祖先结点（现在root为祖先结点）
	int tmp;
	while(v != root) {
		tmp = parent[v];//保存v的爸爸
		parent[v] = root;//将v的爸爸改为最祖先的结点
		v = tmp;//对v的爸爸进行同样的操作
	}
	return v;
}

我们也可以用递归的思路重写上面的代码：

int Find(int v) {
	if(v != parent[v]) {
		parent[v] = Find(parent[v]);
	}
	return parent[v];
}

路径压缩后树的深度明显减少了，利于查找，当我们合并两个树时，选择层数多的树当爸爸会让整个树的深度更小。那么我们在合并操作时，最好让深度比较深的当爸爸。


我们定义一个数组存放每个结点的深度（或者称为rank），初始化为1，即每个结点只包含自己。int rank[maxSize].

for(int i = 0; i < N; i++)
	rank[i] = 1;

重新定义合并函数：

bool Union(int s, int e){
	int sRoot = Find(s);
	int eRoot = Find(e);
	if(sRoot != eRoot){
		if(rank[sRoot] < rank[eRoot]){//sRoot是小树,将其加入大树中
			parent[sRoot] = eRoot;
			rank[eRoot] += rank[sRoot];
		}else{//eRoot为小树,将其加入sRoot中
			parent[eRoot] = sRoot;
			rank[sRoot] += rank[eRoot];
		}
		return true;//s和e爸爸不同,需要合并返回true
	}
	return false;//s和e爸爸相同,不需要合并,返回false
}

2. 克鲁斯卡尔算法

克鲁斯卡尔算法的原理在此不再解释，贪心算法的典型应用。
以下面这个图为例：

上代码：

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

/******图的邻接矩阵存储结构*******/
typedef int VertexType;	//顶点类型, 用户自定义
typedef int EdgeType;	//权值类型, 用户自定义
#define MAXVEX 9		//最大顶点个数
#define INFINITY INT_MAX

vector<int> parent(MAXVEX);
vector<int> Rank(MAXVEX);

typedef struct
{
	vector<VertexType> vexs;	//顶点矩阵
	vector<vector<EdgeType>> arc;//邻接矩阵, 二维矩阵
	int numVertexs, numEdges;	//图中的顶点数和边数
}MGraph;

struct Edge {
	int begin;//这里是无向图,起始节点默认为下标较小的点
	int end;
	int weight;
	bool operator < (const Edge& a) const {
		return weight < a.weight;
	}
};//边集数组

int Find(int v) {
	if (v != parent[v])
		parent[v] = Find(parent[v]);
	return parent[v];
}

bool Union(int s, int e) {
	int sRoot = Find(s);
	int eRoot = Find(e);
	if (sRoot != eRoot) {
		if (Rank[sRoot] < Rank[eRoot]) {//sRoot是小树,将其加入大树中
			parent[sRoot] = eRoot;
			Rank[eRoot] += Rank[sRoot];
		}
		else {//eRoot为小树,将其加入sRoot中
			parent[eRoot] = sRoot;
			Rank[sRoot] += Rank[eRoot];
		}
		return true;//s和e爸爸不同,需要合并返回true
	}
	return false;//s和e爸爸相同,不需要合并,返回false
}
//最小生成树克鲁斯卡尔算法
void MinSpanTree_Kruskal(MGraph G) {
	vector<Edge> edges(G.numEdges);//边集数组
	//根据G的邻接矩阵表示得到边集数组
	int k = 0;
	for (int i = 0; i < G.numVertexs; i++) {
		for (int j = i + 1; j < G.numVertexs; j++) {//无向图的邻接矩阵是对称的,不需要将重复的边添加到边集数组中
			if (G.arc[i][j] != INT_MAX) {
				edges[k].begin = i;
				edges[k].end = j;
				edges[k].weight = G.arc[i][j];
				k++;
			}
		}
	}

	//对边集数组进行排序
	sort(edges.begin(), edges.end());
	//初始化并查集与Rank
	for (int i = 0; i < G.numVertexs; i++) {
		parent[i] = i;//初始化数组值
		Rank[i] = 1;
	}

	for (int i = 0; i < G.numEdges; i++) {
		if (Union(edges[i].begin, edges[i].end)) {
			cout << "(" << edges[i].begin << ", " << edges[i].end << ")\t" << edges[i].weight << endl;
		}
	}
}

int main()
{
	MGraph G;
	G.numVertexs = 9;//9个顶点
	G.numEdges = 15;//15条边
	for (int i = 0; i < G.numVertexs; i++)
		G.vexs.push_back(i);
	//邻接矩阵
	G.arc = {
		{ 0, 10, INFINITY, INFINITY, INFINITY, 11, INFINITY, INFINITY, INFINITY },
		{ 10, 0, 18, INFINITY, INFINITY, INFINITY, 16, INFINITY, 12 },
		{ INFINITY, 18, 0, 22, INFINITY, INFINITY, INFINITY, INFINITY, 8 },
		{ INFINITY, INFINITY, 22, 0, 20, INFINITY, 24, 16, 21 },
		{ INFINITY, INFINITY, INFINITY, 20, 0, 26, INFINITY, 7, INFINITY },
		{ 11, INFINITY, INFINITY, INFINITY, 20, 0, 17, INFINITY, INFINITY },
		{ INFINITY, 16, INFINITY, INFINITY, INFINITY, 17, 0, 19, INFINITY },
		{ INFINITY, INFINITY, INFINITY, 16, 7, INFINITY, 19, 0, INFINITY },
		{ INFINITY, 12, 8, 21, INFINITY, INFINITY, INFINITY, INFINITY, 0 }
	};
	MinSpanTree_Kruskal(G);
	system("pause");
	return 0;
}

在搞清楚并查集之后，再看克鲁斯卡尔算法的实现就比较简单了。
最核心的部分就是这段：

for (int i = 0; i < G.numEdges; i++) {
	if (Union(edges[i].begin, edges[i].end)) {
		cout << "(" << edges[i].begin << ", " << edges[i].end << ")\t" << edges[i].weight << endl;
	}
}

边排序结果：

运行结果：