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;
}
}
边排序结果:
运行结果: