第五十七天 第十一章：图论part07 prim算法精讲 kruskal算法精讲 卡码网 53. 寻宝（第七期模拟笔试）

卡码网 53. 寻宝（第七期模拟笔试）

prim算法精讲(维护节点)

最小生成树 可以使用 prim算法 也可以使用 kruskal算法计算出来。最小生成树是所有节点的最小连通子图， 即：以最小的成本（边的权值）将图中所有节点链接到一起。图中有n个节点，那么一定可以用 n - 1 条边将所有节点连接到一起。

prim算法核心就是三步，prim三部曲，

1. 第一步，选距离生成树最近节点
2. 第二步，最近节点加入生成树
3. 第三步，更新非生成树节点到生成树的距离（即更新minDist数组）

minDist数组用来记录每一个节点距离最小生成树的最近距离。

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

int main(){
    int V,E;
    int s,t,val;
    cin>>V>>E;
    vector<vector<int>> griph(V+1,vector<int>(V+1,10001));
        while(E--){
        cin>>s>>t>>val;
        griph[s][t]=val;
        griph[t][s]=val;
    }
    vector<bool> tree(V+1,false);
    vector<int> mintree(V+1,10001);
    //第一步
    for(int i=1;i<V;i++){
        int cur=-1;
        int min_val=INT_MAX;
        for(int j=1;j<=V;j++){
            if(!tree[j] && mintree[j]<min_val){
                cur=j;
                min_val=mintree[j];
            }
        }
        //第二步
        tree[cur]=true;
        //第三步
        for(int j=1;j<=V;j++){
            if(!tree[j] && griph[cur][j] < mintree[j]){
                mintree[j] = griph[cur][j];
            }
        }
    }
    int res=0;
    for(int i=2;i<=V;i++){
        res+=mintree[i];
    }
    cout<<res;
    return 0;
}

kruskal算法精讲（维护边）

kruscal的思路：

• 边的权值排序，因为要优先选最小的边加入到生成树里
• 遍历排序后的边
  • 如果边首尾的两个节点在同一个集合，说明如果连上这条边图中会出现环
  • 如果边首尾的两个节点不在同一个集合，加入到最小生成树，并把两个节点加入同一个集合

此题要用到并查集。

#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;
}