最小生成树Prim算法和Kruskal算法

最小生成树(Minimum Cost Spanning Tree)

首先，最小生成树是一副连通加权无向图中一棵权值最小的生成树。

主要可以使用Prim和Kruskal算法实现，对于稀疏图来说，用Kruskal写最小生成树效率更好，加上并查集，可对其进行优化。

Kruskal算法（并查集实现）

在使用Kruskal实现最小生成树之前，先来看下并查集需要注意的两点：

1. 针对树可能会退化为链表的解决方案是，每次合并树时，总是将矮的树挂到高的树下，这种方式称为按秩合并。

2. 为了得到的树将更加扁平，加速以后直接或者间接引用节点的速度，Find时改变每一个节点的引用到根节点，这叫路径压缩。

并查集的初始化：

并查集的路径压缩：

并查集的按秩合并

Kruskal算法的步骤包括：

1. 对所有权值进行从小到大排序（这里对边排序时还需要记录边的索引，这样以边的权值排完序后只改变了权值的索引位置）

2. 然后每次选取最小的权值，如果和已有点集构成环则跳过，否则加到该点集中。最终有所有的点集构成的树就是最佳的。

代码实现如下所示：

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

//并查集实现最小生成树
vector<int> u, v, weights, w_r, father;
int mycmp(int i, int j)
{
    return weights[i] < weights[j];
}
int find(int x)
{
    return father[x] == x ? x : father[x] = find(father[x]);
}
void kruskal_test()
{
    int n;
    cin >> n;
    vector<vector<int> > A(n, vector<int>(n));
    for(int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            cin >> A[i][j];
        }
    }

    int edges = 0;
    // 共计n*(n - 1)/2条边
    for (int i = 0; i < n - 1; ++i) {
        for (int j = i + 1; j < n; ++j) {
            u.push_back(i);
            v.push_back(j);
            weights.push_back(A[i][j]);
            w_r.push_back(edges++);
        }
    }
    for (int i = 0; i < n; ++i) {
        father.push_back(i);    // 记录n个节点的根节点，初始化为各自本身
    }

    sort(w_r.begin(), w_r.end(), mycmp); //以weight的大小来对索引值进行排序

    int min_tree = 0, cnt = 0;
    for (int i = 0; i < edges; ++i) {
        int e = w_r[i];    //e代表排序后的权值的索引
        int x = find(u[e]), y = find(v[e]);
        //x不等于y表示u[e]和v[e]两个节点没有公共根节点，可以合并
        if (x != y) {
            min_tree += weights[e];
            father[x] = y;
            ++cnt;
        }
    }
    if (cnt < n - 1) min_tree = 0;
    cout << min_tree << endl;
}

int main(void)
{

    kruskal_test();

    return 0;
}

这里只用到了路径压缩，在合并的时候直接将后一个节点的根节点指到前一个节点的。

 

Prim算法（使用visited数组实现）

Prim算法求最小生成树的时候和边数无关，和顶点树有关，所以适合求解稠密网的最小生成树。

Prim算法的步骤包括：

1. 将一个图分为两部分，一部分归为点集U，一部分归为点集V，U的初始集合为{V1}，V的初始集合为{ALL-V1}。

2. 针对U开始找U中各节点的所有关联的边的权值最小的那个，然后将关联的节点Vi加入到U中，并且从V中删除（注意不能形成环）。

3. 递归执行步骤2，直到V中的集合为空。

4. U中所有节点构成的树就是最小生成树。

代码实现如下所示：

#include <iostream>
#include <vector>
using namespace std;

//Prim算法实现
void prim_test()
{
    int n;
    cin >> n;
    vector<vector<int> > A(n, vector<int>(n));
    for(int i = 0; i < n ; ++i) {
        for(int j = 0; j < n; ++j) {
            cin >> A[i][j];
        }
    }

    int pos, minimum;
    int min_tree = 0;
    //lowcost数组记录每2个点间最小权值，visited数组标记某点是否已访问
    vector<int> visited, lowcost;
    for (int i = 0; i < n; ++i) {
        visited.push_back(0);    //初始化为0，表示都没加入
    }
    visited[0] = 1;   //最小生成树从第一个顶点开始
    for (int i = 0; i < n; ++i) {
        lowcost.push_back(A[0][i]);    //权值初始化为0
    }

    for (int i = 0; i < n; ++i) {    //枚举n个顶点
        minimum = max_int;
        for (int j = 0; j < n; ++j) {    //找到最小权边对应顶点
            if(!visited[j] && minimum > lowcost[j]) {
                minimum = lowcost[j];
                pos = j;
            }
        }
        if (minimum == max_int)    //如果min = max_int表示已经不再有点可以加入最小生成树中
            break;
        min_tree += minimum;
        visited[pos] = 1;     //加入最小生成树中
        for (int j = 0; j < n; ++j) {
            if(!visited[j] && lowcost[j] > A[pos][j]) lowcost[j] = A[pos][j];   //更新可更新边的权值
        }
    }

    cout << min_tree << endl;
}

int main(void)
{
    prim_test();

    return 0;
}

注意：Prim算法实质就是每在最小生成树集合中加入一个点就需要把这个点与集合外的点比较，不断的寻找两个集合之间最小的边。

 

Kruskal VS Prim

方法上：Kruskal在所有边中不断寻找最小的边，Prim在U和V两个集合之间寻找权值最小的连接，共同点是构造过程都不能形成环。

时间上：Prim适合稠密图，复杂度为O(n * n)，因此通常使用邻接矩阵储存，复杂度为O(e * loge)，而Kruskal多用邻接表，稠密图 Prim > Kruskal，稀疏图 Kruskal > Prim。

空间上： Prim适合点少边多，Kruskal适合点多边少。