Borůvka MST算法

当我认为最MST（最小生成树）已经没有什么学的了，才发现世界上还有个这个kruskal和prim结合的玩意

Borůvka 运用并查集的思想，先将每一个初始点集初始化为有且只有自己的点集，然后每一次合并都从所有的独立集合出发，找到一条权值最小的（权值相同，则编号最小）连向其他集合的边，然后合并集合，很容易看出，每次合并都会使集合总数少一半，合并次数大致为log n

相比之下，Borůvka的合并次数要远远少于其他两个常用的MST算法，但是，毕竟不是一般情况下最快的，但是在求解一些个别的（例如边数多，点数较少的完全图）问题有奇效

 luogu MST的例题，过不去，最后一个点会T，毕竟Borůvka是用来解决完全图的，并不是一般情况下最快的

#include "bits/stdc++.h"
using namespace std;
#define LL long long
const int N = 2e5 + 10;
int n,m;
int s[N],t[N],w[N];
struct Boruvka
{
    int f[N],use_edge[N],best[N];
      void init()
    {
    for(int i = 1;i <= n;i ++)    f[i] = i,best[i] = 0;
    for(int i = 1;i <= m;i ++)    use_edge[i] = 0;
      }
      int find(int x)
    {
          return f[x] == x ? x : (f[x] = find(f[x]));
      }
    int better(int x,int y)
    {
    if(!y)    return 1;
    if(w[x] < w[y])    return 1;
    return x < y;
      }
      LL get(void)
    {
    int merge=0;
    LL sum=0;
    while(merge != n - 1)
    {
      for(int i = 1;i <= m;i ++)
      {
        if(use_edge[i])    continue;
        int x = find(s[i]),y = find(t[i]);
        if(x == y)    continue;
        if(better(i,best[x]))    best[x] = i;
        if(better(i,best[y]))    best[y] = i;
      }
      for(int i = 1;i <= n;i ++)
      {
        if(best[i]){
              int x = find(s[best[i]]),y = find(t[best[i]]);
              if(x != y){
                use_edge[best[i]] = 1;
                f[x] = y;
                merge ++;
                sum += w[best[i]];
                      }
                   best[i] = 0;
            }
          }
    }
    return sum;
      }
}g;
int main(void)
{
       ios::sync_with_stdio(false);
      cin >> n >> m;
      for(int i = 1;i <= m;i ++)    cin >> s[i] >> t[i] >> w[i];
      g.init();
       cout << g.get() << '\n';
       return 0;
}

 

 

luogu CF888G XOR-MST

 

 很经典的题，题目大意为:

给定一个n个节点的完全图，每个节点有个编号ai,节点i和节点j之间边的权值为ai xor aj,求该图的最小生成树的权值和。

完全图，优先考虑Borůvka

需要在n log n左右的时间中求出每个连通块最小的连接的边，在这道题中边权可以通过点权求出
但是，这是不能直接算出每条边的边权的，因为这一看就是会超时的

所以根据二进制的性质，考虑建对全局建一个01trie，然后再给每一个连通块建一个tire，Borůvka算法每一次合并两个连通块，就合并两个tire，再在trie上维护子树的size，点权异或最小值就直接在全局trie与当前连通块的size作差得到树上贪心即可

总共会迭代log n次，总时间复杂度为O(n log_n log_size ),空间复杂度为O(n log _size)

 code，仅供参考，没有注释

#include"bits/stdc++.h"
#define ll long long
#define inl inline
#define reg register
#define ls ch[now][0]
#define rs ch[now][1]
using namespace std;
const int N = 2e5 + 10;
const int inf = 0x7ffffff;

int L[N * 40],R[N * 40];
int ch[N * 40][2];
int tot;
int n,a[N],root;
inl int read(void)
{
    int x = 0,f = 1;char ch = getchar();
    while(!isdigit(ch)) f = ch == '-' ? - 1 : f,ch = getchar();
    while(isdigit(ch)) x = (x << 3) + (x << 1) + ch - '0',ch = getchar();
    return x * f;
}
inl void Insert(int &now,int x,int dep)
{
    if(!now) now = ++ tot;
    L[now] = min(L[now],x),R[now] = max(R[now],x);
    if(dep < 0) return;
    int bit = a[x] >> dep & 1;
    Insert(ch[now][bit],x,dep - 1);
}
inl int query(int now,int val,int dep)
{
    if(dep < 0) return 0;
    int bit = val >> dep & 1;
    if(ch[now][bit]) return query(ch[now][bit],val,dep - 1);
    else return query(ch[now][bit ^ 1],val,dep - 1) + (1 << dep);
}
inl ll dfs(int now,int dep)
{
    if(dep < 0) return 0;
    if(R[ls] && R[rs])
    {
        int minn = inf;
        for(int i = L[ls];i <= R[ls];i ++) minn = min(minn,query(rs,a[i],dep - 1));
        return dfs(ls,dep - 1) + dfs(rs,dep - 1)+ minn + (1 << dep);
    }
    if(R[ls]) return dfs(ls,dep - 1);
    if(R[rs]) return dfs(rs,dep - 1);
    return 0;
}
int main(void)
{
    n = read();
    for(int i = 1;i <= n;i ++) a[i] = read();
    sort(a + 1,a + 1 + n);
    memset(L,0x3f,sizeof(L));
    for(int i = 1;i <= n;i ++) Insert(root,i,30);
    printf("%lld\n",dfs(root,30));
    return 0;
}