【Day47 LeetCode】图论问题 Ⅴ

一、图论问题 Ⅴ

今天学习最小生成树算法–prim算法和kruskal算法。最小生成树是所有节点的最小连通子图，有n个节点则必有n-1条边将所有节点连接起来。如何选取n-1条边使得图中所有节点连接到一起，并且边的权值和最小，这就是最小生成树问题。

1、prim算法–寻宝问题

# include<iostream>
# include<vector>
# include<climits>

using namespace std;
int main(){
    int v, e;
    cin >> v >> e;
    int v1, v2, val;
    vector<vector<int>> grid(v + 1, vector<int>(v + 1, 10001));
    for(int i=0; i<e; ++i){
        cin >> v1 >> v2 >> val;
        grid[v1][v2] = val;
        grid[v2][v1] = val;
    }
    vector<int> minDict(v+1, 10001);
    vector<bool> isInTree(v+1, false);
    for(int i=1; i<v; ++i){ // 找v-1条边
        // 1、选距离生成树最近节点
        int cur = -1;
        int minVal = INT_MAX;
        for(int j=1; j<=v; ++j){
            if(!isInTree[j] && minDict[j] < minVal){
                minVal = minDict[j];
                cur = j;
            }
        }
        // 2、最近节点加入生成树
        isInTree[cur] = true;
        // 3、更新非生成树节点到生成树的距离
        for(int j=1; j<=v; ++j){
            if(!isInTree[j] && minDict[j] > grid[cur][j])
                minDict[j] = grid[cur][j];
        }
    }
    int ans = 0;
    for(int i=2; i<=v; ++i)
        ans += minDict[i];
    cout << ans << endl;
    return 0;
}

2、Kruskal算法

kruskal算法也是用于解决最小生成树问题，kruskal 是维护边的集合，而prim 算法是维护节点的集合。
kruskal算法的思路是 1、按照边的权值排序，优先选最小的边加入到生成树里
2、遍历排序后的边：如果边首尾的两个节点在同一个集合，说明如果连上这条边图中会出现环；如果边首尾的两个节点不在同一个集合，加入到最小生成树，并把两个节点加入同一个集合。
在代码实现上，将两个节点加入同一个集合，如何判断两个节点是否在同一个集合呢？这需要用到并查集。并查集之后再介绍。
先给出代码：

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

using namespace std;

// l,r为 边两边的节点，val为边的数值
struct Edge {
    int l, r, val;
};

// 节点数量
int n = 10001;
// 并查集标记节点关系的数组
vector<int> father(n, -1); // 节点编号是从1开始的，n要大一些

// 并查集初始化
void init() {
    for (int i = 0; i < n; ++i) {
        father[i] = i;
    }
}

// 并查集的查找操作
int find(int u) {
    return u == father[u] ? u : father[u] = find(father[u]); // 路径压缩
}

// 并查集的加入集合
void join(int u, int v) {
    u = find(u); // 寻找u的根
    v = find(v); // 寻找v的根
    if (u == v) return ; // 如果发现根相同，则说明在一个集合，不用两个节点相连直接返回
    father[v] = u;
}

int main() {

    int v, e;
    int v1, v2, val;
    vector<Edge> edges;
    int result_val = 0;
    cin >> v >> e;
    while (e--) {
        cin >> v1 >> v2 >> val;
        edges.push_back({v1, v2, val});
    }

    // 执行Kruskal算法
    // 按边的权值对边进行从小到大排序
    sort(edges.begin(), edges.end(), [](const Edge& a, const Edge& b) {
            return a.val < b.val;
    });

    // 并查集初始化
    init();

    // 从头开始遍历边
    for (Edge edge : edges) {
        // 并查集，搜出两个节点的祖先
        int x = find(edge.l);
        int y = find(edge.r);

        // 如果祖先不同，则不在同一个集合
        if (x != y) {
            result_val += edge.val; // 这条边可以作为生成树的边
            join(x, y); // 两个节点加入到同一个集合
        }
    }
    cout << result_val << endl;
    return 0;
}

参考资料：
代码随想录