最小生成树——克鲁斯卡尔(Kruskal)算法

之前学了用普里姆算法来求最小生成树的权值和，但是它的时间复杂度为O(|V²|)，使用优先级队列优化后，可以优化为O(|E|log|V|)。

最小生成树——普里姆算法（prim)

克鲁斯卡尔(Kruskal)算法可以在O(|E|log|E|)的时间复杂度内，求出最小生成树

克鲁斯卡尔算法的核心就是对边进行升序排序，然后从权值最小的边开始，加入最小生成树中，然后利用并查集，把最小生成树中的节点归为同一个集合。一条边只有当它的两个端点不在同一个集合中的时候，才能把它加入最小生成树中。

题目：GRL_2_A

AC代码：

#include <iostream>
#include <algorithm>
#include <string.h>
#include <vector>
#include<cstdio>
using namespace std;

#define MAXV 10005
#define MAXE 100005

struct edge
{
    int from, to, weight;
} eg[4*MAXE];

int v, e;
int head[MAXV] = {0};
int js_edges = 0;
int fa[MAXV] = {0};//并查集
int Rank[MAXV] = {0};

bool cmp(const edge &a,const edge &b)
{
    return a.weight<b.weight;
}


void add_edges(int s,int t,int w)
{
    
    eg[js_edges].from = s;
    eg[js_edges].to =t;
    eg[js_edges].weight = w;
    
    js_edges++;
}

int find_set(int i)
{
    if(fa[i]==i) return i;

    fa[i] = find_set(fa[i]);
    return fa[i];
}

void unite(int x,int y)
{
    int fx = find_set(x);
    int fy = find_set(y);

    if(Rank[fx]>Rank[fy])
    {
        fa[fy] = fx;
    }
    else
    {
        fa[fx] = fy;
        if(Rank[fx]==Rank[fy])
            Rank[fy]++;
    }
}


int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    cin >> v >> e;

    int s, t, w;
    for (int i = 0; i < e; ++i)
    {
        cin >> s >> t >> w;
        add_edges(s,t,w);
        //add_edges(t,s,w);
    }

    sort(eg,eg+js_edges,cmp);//把边的权值按照升序排列

    for(int i=0;i<=v;++i)//初始化并查集
        fa[i] = i;
    
    long long ans=0;

    for(int i=0;i<js_edges;++i)
    {
        if(find_set(eg[i].from)!=find_set(eg[i].to))
        {
            unite(eg[i].from,eg[i].to);
            ans+=eg[i].weight;
            //可以在这里把边加入最小生成树。
        }
    }

    cout<<ans<<endl;
}

转载请注明链接：https://www.longjin666.top/?p=770

欢迎关注我的公众号“灯珑”，让我们一起了解更多的事物~