Boruvka (最小全域木) (graph/mst/boruvka.hpp)

• View this file on GitHub
• View document part on GitHub
• Last update: 2026-08-10 09:29:57+00:00
• Include: #include "graph/mst/boruvka.hpp"

最小全域木(全域木のうち、その辺群の重みの総和が最小になる木)を求める。それぞれの連結成分について、他の連結成分を結ぶ重みが最小の辺を求めて縮約を繰り返すことにより最小全域木を求める。繰り返し回数は $O(\log V)$ 回なので、普通の最小全域木であれば $O(E \log V)$ で求めることができる。

コンストラクタ

explicit Boruvka(size_t V, T INF = numeric_limits<T>::max())

頂点数 V、連結でない場合に返す値 INF で初期化します。

計算量

• $O(V)$

build

T build(const F& update)

最小全域木を求める。update の引数の型は vector< pair< T, int > >& (参照渡しなので注意)。引数で渡された要素のうち、それぞれの代表元について、最小コストで向かえる連結成分の {コスト、その代表元(頂点番号でも良い)} を格納する処理をする(わからないと思うので詳細はverify コードを参照してください)。各頂点 $k$ の代表元を求める際には find(k) を呼び出すこと。

計算量

• $O(E \log V)$

find

inline int find(int k)

現在の頂点 k が属する連結成分の代表元を返す。

Depends on

• Union Find (structure/union-find/union-find.hpp)

Verified with

• test/verify/aoj-grl-2-a-3.test.cpp

Code

#pragma once

#include <algorithm>
#include <cstddef>
#include <limits>
#include <utility>
#include <vector>

#include "../../structure/union-find/union-find.hpp"

/**
 * @brief Boruvka(最小全域木)
 *
 */
template <typename T>
struct Boruvka {
 private:
  std::size_t V;
  UnionFind uf;
  const T INF;

 public:
  explicit Boruvka(std::size_t V, T INF = std::numeric_limits<T>::max())
      : V(V), uf(V), INF(INF) {}

  inline int find(int k) { return uf.find(k); }

  template <typename F>
  T build(const F& update) {
    T ret = T();
    while (uf.size(0) < (int)V) {
      std::vector<std::pair<T, int> > v(V, std::make_pair(INF, -1));
      update(v);
      bool con = false;
      for (int i = 0; i < (int)V; i++) {
        if (v[i].second >= 0 && uf.unite(i, v[i].second)) {
          ret += v[i].first;
          con = true;
        }
      }
      if (!con) return INF;
    }
    return ret;
  }
};

#line 2 "graph/mst/boruvka.hpp"

#include <algorithm>
#include <cstddef>
#include <limits>
#include <utility>
#include <vector>

#line 2 "structure/union-find/union-find.hpp"

#line 7 "structure/union-find/union-find.hpp"

struct UnionFind {
  std::vector<int> data;

  UnionFind() = default;

  explicit UnionFind(std::size_t sz) : data(sz, -1) {}

  bool unite(int x, int y) {
    x = find(x), y = find(y);
    if (x == y) return false;
    if (data[x] > data[y]) std::swap(x, y);
    data[x] += data[y];
    data[y] = x;
    return true;
  }

  int find(int k) {
    if (data[k] < 0) return (k);
    return data[k] = find(data[k]);
  }

  int size(int k) { return -data[find(k)]; }

  bool same(int x, int y) { return find(x) == find(y); }

  std::vector<std::vector<int>> groups() {
    int n = (int)data.size();
    std::vector<std::vector<int>> ret(n);
    for (int i = 0; i < n; i++) {
      ret[find(i)].emplace_back(i);
    }
    ret.erase(
        std::remove_if(ret.begin(), ret.end(),
                       [&](const std::vector<int>& v) { return v.empty(); }),
        ret.end());
    return ret;
  }
};
#line 10 "graph/mst/boruvka.hpp"

/**
 * @brief Boruvka(最小全域木)
 *
 */
template <typename T>
struct Boruvka {
 private:
  std::size_t V;
  UnionFind uf;
  const T INF;

 public:
  explicit Boruvka(std::size_t V, T INF = std::numeric_limits<T>::max())
      : V(V), uf(V), INF(INF) {}

  inline int find(int k) { return uf.find(k); }

  template <typename F>
  T build(const F& update) {
    T ret = T();
    while (uf.size(0) < (int)V) {
      std::vector<std::pair<T, int> > v(V, std::make_pair(INF, -1));
      update(v);
      bool con = false;
      for (int i = 0; i < (int)V; i++) {
        if (v[i].second >= 0 && uf.unite(i, v[i].second)) {
          ret += v[i].first;
          con = true;
        }
      }
      if (!con) return INF;
    }
    return ret;
  }
};

Back to top page