图论最小生成树 Boruvka算法

最新推荐文章于 2024-11-11 05:28:12 发布

HeartFireY

最新推荐文章于 2024-11-11 05:28:12 发布

阅读量3.4k

点赞数 7

CC 4.0 BY-SA版权

分类专栏：图论算法学习文章标签：图论算法数据结构

本文链接：https://blog.csdn.net/yanweiqi1754989931/article/details/121238116

算法学习同时被 2 个专栏收录

38 篇文章

订阅专栏

图论

7 篇文章

订阅专栏

本文介绍了Boruvka算法，作为Kruskal和Prim算法的补充，适用于边数量极大的图问题。Boruvka算法通过不断寻找并合并不同连通块间的最短边来构建最小生成树。其核心思想是在并查集中逐步合并独立子集，直至所有节点连通。文章提供了算法的详细步骤和C++实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

一、前导

1.Kruskal和Prim的回顾

首先我们对 $K r u s k a l$ 和 $P r i m$ u算法进行回顾：

$K r u s k a l$ 算法的基本思想是维护一个森林，查询两个结点是否在同一棵树中，并连接两棵树。在实际的算法过程中，我们需要对边集进行排序，复杂度 $\log m)$ ，并使用 $\log n)$ 并查集维护集合。总复杂度 $\log m)$ 。因此对于稠密图， $K r u s k a l$ 显得有些"水土不服"。
$P r i m$ 算法的基本思想是每次需要寻找距离最小的一个结点(与Dijkstra’s Algorithm相似)，以及新的边来更新其它结点的距离。在寻找距离最小点的过程中，可以暴力查找，也可以采用堆维护进行优化。在使用二叉堆优化的加持下，复杂度 $m)\log n)$ 。相比于 $K r u s k a l$ ， $P r i m$ 更适用于稠密图。

对于最小生成树，我们一般将这类问题进行分类，对于稀松图选择 $K r u s k a l$ 求解，对于稠密图则使用 $P r i m$ 算法进行求解。

2.Boruvka算法引入

很容易发现，对于某些毒瘤的问题，边的数量极其大，而边集内部又存在各种规律可能需要套上各种数据结构加以优化。但是此时 $K r u s k a l$ 和 $P r i m$ 并不能很好的嵌合进这些数据结构。此时我们可以引入 $B o r u v k a$ 算法。

对于 $B o r u v k a$ 算法，一个比较笼统的表述是，一个多路增广版本的 $K r u s k a l$ 。它的思想是一开始所有点看做独立子集，每次遍历边找到两个集合(连通块)之间连接的最短边，不断扩大集合(连通块)直到所有点合并为一个集合(连通块)。

二、Brouvka原理与实现

1.基本原理

在并查集算法中，初始状态下我们将每个点视为一个独立的点集，并不断地合并集合。在 $B r o u v k a$ 算法中，我们在一开始将所有点视为独立子集，每次我们找到两个集合(即为连通块)之间的最短边，然后扩展连通块进行合并。

可以发现， $B o r u v k a$ 算法将求解最小生成树的问题分解为求连通块间最小边的问题。它的基本思想是：

生成树中所有顶点必然是连通的，所以两个不相交集必须连接起来才能构成生成树，而且所选择的连接边的权重必须最小，才能得到最小生成树。

2.基本过程

首先将所有点视为各自独立的集合，初始化一个空的 $M S T$ ;
当子集个数大于 $1$ 的时候，对各个子集和执行以下操作：
1. 找到与当前集合有边的集合，选出权值最小的边；
2. 如果该权值最小的边不在 $M S T$ 中；

3.实现

#include <bits/stdc++.h>
using namespace std;

const int N = 1e5 + 10;
const int M = 1e6 + 10;

struct node { int u, v, w; } edge[M];

int f[N], best[N];
bool vis[N];
int n, m;

int find(int x){
    return f[x] == x ? x : find(f[x]);
}

inline const bool cmp(int u, int v){
    if(v == 0) return 1;
    if(edge[u].w != edge[v].w) return edge[u].w < edge[v].w;
    return u < v;
}

inline void init(){
    cin >> n >> m;
    for(int i = 1; i <= m; i++) cin >> edge[i].u >> edge[i].v >> edge[i].w;
    for(int i = 1; i <= n; i++) f[i] = i;
}

inline int boruvka(){
    memset(vis, 0, sizeof(vis));
    int ans = 0, cnt = 0;
    bool status = true;
    while(true){
        status = false;
        //遍历边集
        for(int i = 1; i <= m; i++){
            if(!vis[i]){
                int uu = find(edge[i].u), vv = find(edge[i].v);
                if(uu == vv) continue;
                if(cmp(i, best[uu])) best[uu] = i;
                if(cmp(i, best[vv])) best[vv] = i; 
            }
        }
        //遍历点集
        for(int i = 1; i <= n; i++){
            if(best[i] && !vis[best[i]]){
                status = true, cnt++, ans += edge[best[i]].w;
                vis[best[i]] = 1;
                int uu = find(edge[best[i]].u), vv = find(edge[best[i]].v);
                f[uu] = vv;
            }
        }
    }
    if(cnt == n - 1) return ans;
    return -1;
}

signed main(){
    init();
    boruvka();
    return 0;
}