Kruskal算法详解

在prim算法的基础上，我们来介绍一下Kruskal算法。如果还不太了解prim算法，可以看这篇博客lazy prim算法详解
Kruskal算法的核心依旧是切分定理。对于一个图，显然我们可以找到所有权值中最小的边。那么这条边一定是最小生成树。为什么这么说呢？因为我们总可以切分使得这条边是一条横切边。这样，我们就可以把这一条边连接的两个顶点划入红色阵营。我们再找到次小的边，此时它实际是蓝色阵营的最小的边。它只要不与红色阵营的边构成环，他就是最小生成树。

理由依旧是我们总可以切分使得这条边是一条横切边。那么，我们就可以将整个权值排个序，从小到大找。只要不成环，那么就是最小生成树。
这个算法的关键在于如何判断是否成环。

其实非常简单，我们可以用并查集来判断。

我们可以把所有的最小生成树的顶点进行一次union操作，使其根相同。那么，对于u、v顶点来说，如果他们根相同，这时在连接u、v顶点必然会构成环。由此我们就得到了判断是否成环的方法。

#include<iostream>
#include<queue>
#define INF 1e4
using namespace std;
double G[8][8] =
{
 //0   1   2   3   4   5   6   7 
 {INF,INF,0.26,INF,0.38,INF,0.58,0.16},
 {INF,INF,0.36,0.29,INF,0.32,INF,0.19},
 {0.26,0.36,INF,0.17,INF,INF,0.40,0.34},
 {INF,0.29,0.17,INF,INF,INF,0.52,INF},
 {0.38,INF,INF,INF,INF,0.35,0.93,0.37},
 {INF,0.32,INF,INF,0.35,INF,INF,0.28},
 {0.58,INF,0.40,0.52,0.93,INF,INF,INF},
 {0.16,0.19,0.34,INF,0.37,0.28,INF,INF}
};//数组初始化
//定义一个结构体，表明这是一个由v、u连接的边，权值为w
//并将运算符重载，比较大小的是比较权值
struct Edge {
 int v;
 int u;
 double w;
 bool operator < (const Edge& a) const {
  return w > a.w;
 }
};
priority_queue<Edge,vector<Edge>,less<Edge> > w;
int uf[8] = { 0,1,2,3,4,5,6,7 };
//并查集
int find(int x) {
 if (x != uf[x])
  return find(uf[x]);
 else return x;
}
void unity(int x, int y) {
 int rootx = find(x);
 int rooty = find(y);
 uf[rootx] = rooty;
}
int main()
{
 for (int i = 0; i < 8; i++) {
  for (int j = 0; j < 8; j++) {
   if (i > j)
    w.push({ i,j,G[i][j] });
  }
 }
 double minw = 0;
 while (!w.empty()) {
  Edge e = w.top();
  w.pop();
  if (find(e.u) == find(e.v))
   continue;
  unity(e.u, e.v);
  minw += e.w;
 }
 cout << minw;
 return 0;
}