最小生成树 C++简洁实现

只涉及代码实现，没有理论讲解

1.普利姆算法

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

using namespace std;

int prime(vector<vector<int>>& edge){
    int n = edge.size();
    vector<bool> visit(n, false);
    vector<int> dis(n, INT_MAX);

    dis[1] = 0;
    int ans = 0;
    for(int i=1; i<n; ++i){
        int u=-1, mins=INT_MAX;
        // 在dis中找到路径最近的一个节点
        for(int j=1; j<n; ++j){
            if(visit[j]==false && dis[j]<mins){
                u = j;
                mins = dis[j];
            }
        }
        if(u==-1) return -1;
        // 将节点加入最短路径
        visit[u] = true;
        ans += dis[u];

        // 更新dis中的到当前最短路径的距离
        for(int v=1; v<n; ++v){
            if(visit[v]==false && edge[u][v] < dis[v])
                dis[v] = edge[u][v];
        }
    }
    return ans;
}


int main(){
    int a, b, w;
    int n, m;
    cin>>n>>m;
    vector<vector<int>> edge(n+1, vector<int>(n+1, INT_MAX));
    for(int i=0; i<m; ++i){
        cin>>a>>b>>w;
        edge[a][b] = w;
        edge[b][a] = w;
    }
    cout<<prime(edge);
}
/*
4 5
1 2 2
1 3 3
1 4 5
2 4 4
3 4 1
*/
/*
4 5
1 2 2
1 3 3
1 4 5
2 4 4
3 4 1
*/

2. 克鲁斯卡尔

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

using namespace std;
struct Edge{
    int start;
    int end;
    int weight;
    Edge(int s, int e, int w):start(s), end(e), weight(w){}
};

vector<int> father(100, 0);
void init(int n){
    for(int i=1; i<n; ++i)
        father[i] = i;
}
int find(int x){
    if(x!=father[x])
        x = find(father[x]);
    return x;
}
void merge(int i, int j){
    int x=find(i), y=find(j);
    if(x==y) return;
    father[x] = y;
}

void Kruskal(vector<Edge>& vec){
    sort(vec.begin(), vec.end(), [](Edge& e1, Edge& e2){
        return e1.weight < e2.weight;
    });

    int res = 0;
    set<pair<int, int>> path;
    for(int i=0; i<vec.size(); ++i){
        int x=find(vec[i].start), y=find(vec[i].end);
        if(x==y) continue;
        merge(x, y);
        path.insert({vec[i].start, vec[i].end});
        res += vec[i].weight;
    }

    // 输出最小生成数的路径和以及边
    cout<<res<<endl;
    for(auto m : path)
        cout<<m.first<<" "<<m.second<<endl;
}

int main(){
    int n,m;
    cin>>n>>m;
    int a, b, w;
    vector<Edge> vec; //存储所有边界点信息
    init(n+1);
    for(int i=0; i<m; ++i){
        cin>>a>>b>>w;
        vec.emplace_back(Edge(a, b, w));
    }
    Kruskal(vec);
}
/*
4 5
1 2 2
1 3 3
1 4 5
2 4 4
3 4 1
*/