图 之 MST（最小生成树 — kruskal算法 ）并查集实现

#并查集的优化：

（1） Find_Set(x)时，路径压缩寻找祖先时，我们一般采用递归查找，但是当元素很多亦或是整棵树变为一条链时，每次Find_Set(x)都是O(n)的复杂度。为了避免这种情况，我们需对路径进行压缩，即当我们经过”递推”找到祖先节点后，”回溯”的时候顺便将它的子孙节点都直接指向祖先，这样以后再次Find_Set(x)时复杂度就变成O(1)了，如下图所示。可见，路径压缩方便了以后的查找。

（2） Union(x,y)时，按秩合并，即合并的时候将元素少的集合合并到元素多的集合中，这样合并之后树的高度会相对较小。

【输入】：

11

A B 7

A D 5

B C 8

B D 9

B E 7

C E 5

D E 15

D F 6

E F 8

E G 9

F G 11

【输出】：

A - D : 5

C - E : 5

D - F : 6

A - B : 7

B - E : 7

E - G : 9

39

【代码】：

#include<stdio.h>
#include<iostream>
#include<algorithm>

using namespace std;

#define max_num 100

/*
* 表示图的边
*/
typedef struct edge {
int x,y;
int w;
} edge;

edge e[max_num];
int n = 0;

//定义并查集 的parent数组和rank数组（树的深度-1——严谨的说）
int parent[max_num];
int rank[max_num];

//最小代价
int sum = 0;

//cmp函数-> 将e数组按权值w排序，当w相同，按x的升序
bool cmp(edge a,edge b) {
if(a.w != b.w) {
return a.w<b.w;
} else {
return a.x<b.x;
}
}

/*
* 并查集
*/
void makeSet(int x) {
parent[x] = x;
rank[x] = 0;
}

int findSet(int x) {
if(x != parent[x]) {
parent[x] = findSet(parent[x]);
}
return parent[x];
}

void unionSet(int x, int y, int w) {
sum += w;

if(x == y) return;

if(rank[x]>rank[y]) {
parent[y] = x;
} else {
if(rank[x] == rank[y]) {
rank[y]++;
}
parent[x] = y;
}
}

//图的创建
void creatGraph() {
int x, y;
char chx, chy;
cin>>n;

for(int i = 0; i<n; i++) {
cin>>chx>>chy>>e[i].w;
//  getchar();
e[i].x = chx - 'A';
e[i].y = chy - 'A';
makeSet(i);
}
}

/*
* kruskal algorithm
* 1.按权值将边数组排序
* 2.按顺序加入到MST中，前提是不会产生回路
*/
void kruskal() {
int x,y;

sort(e,e+n,cmp);
/*
for(int i = 0; i<n; i++) {
cout<<e[i].w<<endl;
}
*/
for(int i = 0; i<n; i++) {
x = findSet(e[i].x);
y = findSet(e[i].y);

if(x != y) {
printf("%c - %c : %d\n",e[i].x+'A', e[i].y+'A', e[i].w);
unionSet(x, y, e[i].w);
}
}
cout<<sum<<endl;
}

int main() {

creatGraph();
kruskal();

return 0;
}