cp-library

C++ Library for Competitive Programming

View the Project on GitHub emthrm/cp-library

:heavy_check_mark: 一般グラフの最大マッチング (maximum matching)
(include/emthrm/graph/flow/matching/maximum_matching.hpp)

マッチング (matching)

互いに端点を共有しない辺集合である。

辺被覆 (edge cover)

任意の頂点がいずれかの端点となっている辺集合である。

独立集合 (independent set) / 安定集合 (stable set)

互いに隣接していない頂点集合である。

頂点被覆 (vertex cover)

任意の辺に対して少なくとも一方の端点を含む頂点集合である。

クリーク (clique)

無向グラフに対して完全グラフな部分グラフである。

性質

  1. 孤立点のないグラフに対して (最大マッチングのサイズ) + (最小辺被覆のサイズ) = (頂点数) が成り立つ。

  2. (最大独立集合のサイズ) + (最小頂点被覆のサイズ) = (頂点数)

  3. 二部グラフ $(U, V, E)$ に対して $\lvert U \rvert = \lvert V \rvert \implies (\text{完全二部マッチングの個数}) \equiv \lvert A \rvert \pmod{2}$ が成り立つ。ただし $A$ は $a_{ij} = \begin{cases} 1 & (\lbrace U_i, V_j \rbrace \in E), \\ 0 & (\text{otherwise}) \end{cases}$ を満たす $\lvert U \rvert \times \lvert V \rvert$ 型行列である。

  4. 二部グラフに対して、最大マッチングのサイズは最小頂点被覆のサイズに等しい。

  5. 有向非巡回グラフの最小パス被覆は二部グラフの最大マッチングに帰着できる。

Hall’s theorem

二部グラフ $(U, V, E)$ に対して、以下は同値である。

Dilworth’s theorem

任意の有限な半順序集合に対して、反鎖 (antichain) の最大サイズは共通部分のない鎖 (chain) に分解したときの最小サイズに等しい。

特に有向非巡回グラフ $G$ では、$\forall u, v \in V(G)$ に対して

\[u \leq v \iff u \text{ から } v \text{ に到達可能である。}\]

と定義すると、$(V(G), \leq)$ は半順序集合である。$(V(G), \leq)$ に対して、共通部分のない鎖に分解したときの最小サイズは最小パス被覆のサイズを意味する。

時間計算量

  時間計算量
二部グラフの最大マッチング $O(\lvert V \rvert \lvert E \rvert)$
Hopcroft–Karp algorithm $O(\lvert E \rvert \sqrt{\lvert V \rvert})$
二部グラフの重み付き最大マッチング $O(\lvert E \rvert \lvert V \rvert \log{\lvert V \rvert})$
一般グラフの最大マッチング $O({\lvert V \rvert}^3 + \lvert E \rvert)$

仕様

二部グラフの最大マッチング

struct BipartiteMatching;

メンバ変数

名前 説明
std::vector<int> match マッチした相手。ただし存在しないときは $-1$ となる。

メンバ関数

名前 効果・戻り値
explicit BipartiteMatching(const int n); 頂点数 $N$ のオブジェクトを構築する。
void add_edge(const int u, const int v); 辺 $(u, v)$ を加える。
int solve(); 最大マッチングのサイズ
void fix(const int ver); 頂点 $\mathrm{ver}$ に対するマッチングを固定する。
int activate(const int ver); 頂点 $\mathrm{ver}$ を有効にしたのち、最大マッチングのサイズの変化量を返す。
int deactivate(const int ver); 頂点 $\mathrm{ver}$ を無効にしたのち、最大マッチングのサイズの変化量を返す。

Hopcroft–Karp algorithm

struct HopcroftKarp;

メンバ変数

名前 説明
std::vector<int> match マッチした相手。ただし存在しないときは $-1$ となる。

メンバ関数

名前 効果・戻り値
explicit HopcroftKarp(const int left, const int right); 頂点数 $\mathrm{left}$ と $\mathrm{right}$ の二部グラフに対してオブジェクトを構築する。
void add_edge(const int u, const int v); 辺 $(u, v)$ を加える。
int solve(); 最大マッチングのサイズ

二部グラフの重み付き最大マッチング

template <typename T>
struct WeightedBipartiteMatching;

メンバ関数

名前 効果・戻り値  
explicit WeightedBipartiteMatching(const int left, const int right); 頂点数 $\mathrm{left}$ と $\mathrm{right}$ の二部グラフに対してオブジェクトを構築する。  
void add_edge(const int src, const int dst, const T cost); 重み $\mathrm{cost}$ の辺 $(\mathrm{src}, \mathrm{dst})$ を加える。  
T solve(); 重み付き最大マッチングの重み  
std::vector<int> matching() const; マッチした相手。ただし存在しないときは $-1$ が格納される。  

一般グラフの最大マッチング

名前 戻り値
int maximum_matching(const std::vector<std::vector<int>>& graph); 無向グラフ $\mathrm{graph}$ の最大マッチングのサイズ

参考文献

性質3

性質5・Dilworth’s theorem

Hall’s theorem

二部グラフの最大マッチング

Hopcroft–Karp algorithm

二部グラフの重み付き最大マッチング

一般グラフの最大マッチング

TODO

Submissons

Depends on

Verified with

Code

#ifndef EMTHRM_GRAPH_FLOW_MATCHING_MAXIMUM_MATCHING_HPP_
#define EMTHRM_GRAPH_FLOW_MATCHING_MAXIMUM_MATCHING_HPP_

#include <random>
#include <vector>

#include "emthrm/math/matrix/gauss_jordan.hpp"
#include "emthrm/math/matrix/matrix.hpp"
#include "emthrm/math/modint.hpp"

namespace emthrm {

int maximum_matching(const std::vector<std::vector<int>>& graph) {
  constexpr unsigned int P = 1000000007;
  using ModInt = MInt<P>;
  ModInt::set_mod(P);
  static std::mt19937_64 engine(std::random_device {} ());
  static std::uniform_int_distribution<> dist(1, P - 1);
  const int n = graph.size();
  Matrix<ModInt> tutte_matrix(n, n, 0);
  for (int i = 0; i < n; ++i) {
    for (const int j : graph[i]) {
      if (j > i) {
        const ModInt x = ModInt::raw(dist(engine));
        tutte_matrix[i][j] = x;
        tutte_matrix[j][i] = -x;
      }
    }
  }
  return gauss_jordan(&tutte_matrix, ModInt(0)) / 2;
}

}  // namespace emthrm

#endif  // EMTHRM_GRAPH_FLOW_MATCHING_MAXIMUM_MATCHING_HPP_
#line 1 "include/emthrm/graph/flow/matching/maximum_matching.hpp"



#include <random>
#include <vector>

#line 1 "include/emthrm/math/matrix/gauss_jordan.hpp"



#include <utility>

#line 1 "include/emthrm/math/matrix/matrix.hpp"



#line 5 "include/emthrm/math/matrix/matrix.hpp"

namespace emthrm {

template <typename T>
struct Matrix {
  explicit Matrix(const int m, const int n, const T def = 0)
      : data(m, std::vector<T>(n, def)) {}

  int nrow() const { return data.size(); }
  int ncol() const { return data.empty() ? 0 : data.front().size(); }

  Matrix pow(long long exponent) const {
    const int n = nrow();
    Matrix<T> res(n, n, 0), tmp = *this;
    for (int i = 0; i < n; ++i) {
      res[i][i] = 1;
    }
    for (; exponent > 0; exponent >>= 1) {
      if (exponent & 1) res *= tmp;
      tmp *= tmp;
    }
    return res;
  }

  inline const std::vector<T>& operator[](const int i) const { return data[i]; }
  inline std::vector<T>& operator[](const int i) { return data[i]; }

  Matrix& operator=(const Matrix& x) = default;

  Matrix& operator+=(const Matrix& x) {
    const int m = nrow(), n = ncol();
    for (int i = 0; i < m; ++i) {
      for (int j = 0; j < n; ++j) {
        data[i][j] += x[i][j];
      }
    }
    return *this;
  }

  Matrix& operator-=(const Matrix& x) {
    const int m = nrow(), n = ncol();
    for (int i = 0; i < m; ++i) {
      for (int j = 0; j < n; ++j) {
        data[i][j] -= x[i][j];
      }
    }
    return *this;
  }

  Matrix& operator*=(const Matrix& x) {
    const int m = nrow(), l = ncol(), n = x.ncol();
    std::vector<std::vector<T>> res(m, std::vector<T>(n, 0));
    for (int i = 0; i < m; ++i) {
      for (int k = 0; k < l; ++k) {
        for (int j = 0; j < n; ++j) {
          res[i][j] += data[i][k] * x[k][j];
        }
      }
    }
    data.swap(res);
    return *this;
  }

  Matrix operator+(const Matrix& x) const { return Matrix(*this) += x; }
  Matrix operator-(const Matrix& x) const { return Matrix(*this) -= x; }
  Matrix operator*(const Matrix& x) const { return Matrix(*this) *= x; }

 private:
  std::vector<std::vector<T>> data;
};

}  // namespace emthrm


#line 7 "include/emthrm/math/matrix/gauss_jordan.hpp"

namespace emthrm {

template <bool IS_EXTENDED = false, typename T>
int gauss_jordan(Matrix<T>* a, const T eps = 1e-8) {
  const int m = a->nrow(), n = a->ncol();
  int rank = 0;
  for (int col = 0; col < (IS_EXTENDED ? n - 1 : n); ++col) {
    int pivot = -1;
    T mx = eps;
    for (int row = rank; row < m; ++row) {
      const T abs = ((*a)[row][col] < 0 ? -(*a)[row][col] : (*a)[row][col]);
      if (abs > mx) {
        pivot = row;
        mx = abs;
      }
    }
    if (pivot == -1) continue;
    std::swap((*a)[rank], (*a)[pivot]);
    T tmp = (*a)[rank][col];
    for (int col2 = 0; col2 < n; ++col2) {
      (*a)[rank][col2] /= tmp;
    }
    for (int row = 0; row < m; ++row) {
      if (row != rank &&
          ((*a)[row][col] < 0 ? -(*a)[row][col] : (*a)[row][col]) > eps) {
        tmp = (*a)[row][col];
        for (int col2 = 0; col2 < n; ++col2) {
          (*a)[row][col2] -= (*a)[rank][col2] * tmp;
        }
      }
    }
    ++rank;
  }
  return rank;
}

}  // namespace emthrm


#line 1 "include/emthrm/math/modint.hpp"



#ifndef ARBITRARY_MODINT
# include <cassert>
#endif
#include <compare>
#include <iostream>
// #include <numeric>
#line 12 "include/emthrm/math/modint.hpp"

namespace emthrm {

#ifndef ARBITRARY_MODINT
template <unsigned int M>
struct MInt {
  unsigned int v;

  constexpr MInt() : v(0) {}
  constexpr MInt(const long long x) : v(x >= 0 ? x % M : x % M + M) {}
  static constexpr MInt raw(const int x) {
    MInt x_;
    x_.v = x;
    return x_;
  }

  static constexpr int get_mod() { return M; }
  static constexpr void set_mod(const int divisor) {
    assert(std::cmp_equal(divisor, M));
  }

  static void init(const int x) {
    inv<true>(x);
    fact(x);
    fact_inv(x);
  }

  template <bool MEMOIZES = false>
  static MInt inv(const int n) {
    // assert(0 <= n && n < M && std::gcd(n, M) == 1);
    static std::vector<MInt> inverse{0, 1};
    const int prev = inverse.size();
    if (n < prev) return inverse[n];
    if constexpr (MEMOIZES) {
      // "n!" and "M" must be disjoint.
      inverse.resize(n + 1);
      for (int i = prev; i <= n; ++i) {
        inverse[i] = -inverse[M % i] * raw(M / i);
      }
      return inverse[n];
    }
    int u = 1, v = 0;
    for (unsigned int a = n, b = M; b;) {
      const unsigned int q = a / b;
      std::swap(a -= q * b, b);
      std::swap(u -= q * v, v);
    }
    return u;
  }

  static MInt fact(const int n) {
    static std::vector<MInt> factorial{1};
    if (const int prev = factorial.size(); n >= prev) {
      factorial.resize(n + 1);
      for (int i = prev; i <= n; ++i) {
        factorial[i] = factorial[i - 1] * i;
      }
    }
    return factorial[n];
  }

  static MInt fact_inv(const int n) {
    static std::vector<MInt> f_inv{1};
    if (const int prev = f_inv.size(); n >= prev) {
      f_inv.resize(n + 1);
      f_inv[n] = inv(fact(n).v);
      for (int i = n; i > prev; --i) {
        f_inv[i - 1] = f_inv[i] * i;
      }
    }
    return f_inv[n];
  }

  static MInt nCk(const int n, const int k) {
    if (n < 0 || n < k || k < 0) [[unlikely]] return MInt();
    return fact(n) * (n - k < k ? fact_inv(k) * fact_inv(n - k) :
                                  fact_inv(n - k) * fact_inv(k));
  }
  static MInt nPk(const int n, const int k) {
    return n < 0 || n < k || k < 0 ? MInt() : fact(n) * fact_inv(n - k);
  }
  static MInt nHk(const int n, const int k) {
    return n < 0 || k < 0 ? MInt() : (k == 0 ? 1 : nCk(n + k - 1, k));
  }

  static MInt large_nCk(long long n, const int k) {
    if (n < 0 || n < k || k < 0) [[unlikely]] return MInt();
    inv<true>(k);
    MInt res = 1;
    for (int i = 1; i <= k; ++i) {
      res *= inv(i) * n--;
    }
    return res;
  }

  constexpr MInt pow(long long exponent) const {
    MInt res = 1, tmp = *this;
    for (; exponent > 0; exponent >>= 1) {
      if (exponent & 1) res *= tmp;
      tmp *= tmp;
    }
    return res;
  }

  constexpr MInt& operator+=(const MInt& x) {
    if ((v += x.v) >= M) v -= M;
    return *this;
  }
  constexpr MInt& operator-=(const MInt& x) {
    if ((v += M - x.v) >= M) v -= M;
    return *this;
  }
  constexpr MInt& operator*=(const MInt& x) {
    v = (unsigned long long){v} * x.v % M;
    return *this;
  }
  MInt& operator/=(const MInt& x) { return *this *= inv(x.v); }

  constexpr auto operator<=>(const MInt& x) const = default;

  constexpr MInt& operator++() {
    if (++v == M) [[unlikely]] v = 0;
    return *this;
  }
  constexpr MInt operator++(int) {
    const MInt res = *this;
    ++*this;
    return res;
  }
  constexpr MInt& operator--() {
    v = (v == 0 ? M - 1 : v - 1);
    return *this;
  }
  constexpr MInt operator--(int) {
    const MInt res = *this;
    --*this;
    return res;
  }

  constexpr MInt operator+() const { return *this; }
  constexpr MInt operator-() const { return raw(v ? M - v : 0); }

  constexpr MInt operator+(const MInt& x) const { return MInt(*this) += x; }
  constexpr MInt operator-(const MInt& x) const { return MInt(*this) -= x; }
  constexpr MInt operator*(const MInt& x) const { return MInt(*this) *= x; }
  MInt operator/(const MInt& x) const { return MInt(*this) /= x; }

  friend std::ostream& operator<<(std::ostream& os, const MInt& x) {
    return os << x.v;
  }
  friend std::istream& operator>>(std::istream& is, MInt& x) {
    long long v;
    is >> v;
    x = MInt(v);
    return is;
  }
};
#else  // ARBITRARY_MODINT
template <int ID>
struct MInt {
  unsigned int v;

  constexpr MInt() : v(0) {}
  MInt(const long long x) : v(x >= 0 ? x % mod() : x % mod() + mod()) {}
  static constexpr MInt raw(const int x) {
    MInt x_;
    x_.v = x;
    return x_;
  }

  static int get_mod() { return mod(); }
  static void set_mod(const unsigned int divisor) { mod() = divisor; }

  static void init(const int x) {
    inv<true>(x);
    fact(x);
    fact_inv(x);
  }

  template <bool MEMOIZES = false>
  static MInt inv(const int n) {
    // assert(0 <= n && n < mod() && std::gcd(x, mod()) == 1);
    static std::vector<MInt> inverse{0, 1};
    const int prev = inverse.size();
    if (n < prev) return inverse[n];
    if constexpr (MEMOIZES) {
      // "n!" and "M" must be disjoint.
      inverse.resize(n + 1);
      for (int i = prev; i <= n; ++i) {
        inverse[i] = -inverse[mod() % i] * raw(mod() / i);
      }
      return inverse[n];
    }
    int u = 1, v = 0;
    for (unsigned int a = n, b = mod(); b;) {
      const unsigned int q = a / b;
      std::swap(a -= q * b, b);
      std::swap(u -= q * v, v);
    }
    return u;
  }

  static MInt fact(const int n) {
    static std::vector<MInt> factorial{1};
    if (const int prev = factorial.size(); n >= prev) {
      factorial.resize(n + 1);
      for (int i = prev; i <= n; ++i) {
        factorial[i] = factorial[i - 1] * i;
      }
    }
    return factorial[n];
  }

  static MInt fact_inv(const int n) {
    static std::vector<MInt> f_inv{1};
    if (const int prev = f_inv.size(); n >= prev) {
      f_inv.resize(n + 1);
      f_inv[n] = inv(fact(n).v);
      for (int i = n; i > prev; --i) {
        f_inv[i - 1] = f_inv[i] * i;
      }
    }
    return f_inv[n];
  }

  static MInt nCk(const int n, const int k) {
    if (n < 0 || n < k || k < 0) [[unlikely]] return MInt();
    return fact(n) * (n - k < k ? fact_inv(k) * fact_inv(n - k) :
                                  fact_inv(n - k) * fact_inv(k));
  }
  static MInt nPk(const int n, const int k) {
    return n < 0 || n < k || k < 0 ? MInt() : fact(n) * fact_inv(n - k);
  }
  static MInt nHk(const int n, const int k) {
    return n < 0 || k < 0 ? MInt() : (k == 0 ? 1 : nCk(n + k - 1, k));
  }

  static MInt large_nCk(long long n, const int k) {
    if (n < 0 || n < k || k < 0) [[unlikely]] return MInt();
    inv<true>(k);
    MInt res = 1;
    for (int i = 1; i <= k; ++i) {
      res *= inv(i) * n--;
    }
    return res;
  }

  MInt pow(long long exponent) const {
    MInt res = 1, tmp = *this;
    for (; exponent > 0; exponent >>= 1) {
      if (exponent & 1) res *= tmp;
      tmp *= tmp;
    }
    return res;
  }

  MInt& operator+=(const MInt& x) {
    if ((v += x.v) >= mod()) v -= mod();
    return *this;
  }
  MInt& operator-=(const MInt& x) {
    if ((v += mod() - x.v) >= mod()) v -= mod();
    return *this;
  }
  MInt& operator*=(const MInt& x) {
    v = (unsigned long long){v} * x.v % mod();
    return *this;
    }
  MInt& operator/=(const MInt& x) { return *this *= inv(x.v); }

  auto operator<=>(const MInt& x) const = default;

  MInt& operator++() {
    if (++v == mod()) [[unlikely]] v = 0;
    return *this;
  }
  MInt operator++(int) {
    const MInt res = *this;
    ++*this;
    return res;
  }
  MInt& operator--() {
    v = (v == 0 ? mod() - 1 : v - 1);
    return *this;
  }
  MInt operator--(int) {
    const MInt res = *this;
    --*this;
    return res;
  }

  MInt operator+() const { return *this; }
  MInt operator-() const { return raw(v ? mod() - v : 0); }

  MInt operator+(const MInt& x) const { return MInt(*this) += x; }
  MInt operator-(const MInt& x) const { return MInt(*this) -= x; }
  MInt operator*(const MInt& x) const { return MInt(*this) *= x; }
  MInt operator/(const MInt& x) const { return MInt(*this) /= x; }

  friend std::ostream& operator<<(std::ostream& os, const MInt& x) {
    return os << x.v;
  }
  friend std::istream& operator>>(std::istream& is, MInt& x) {
    long long v;
    is >> v;
    x = MInt(v);
    return is;
  }

 private:
  static unsigned int& mod() {
    static unsigned int divisor = 0;
    return divisor;
  }
};
#endif  // ARBITRARY_MODINT

}  // namespace emthrm


#line 10 "include/emthrm/graph/flow/matching/maximum_matching.hpp"

namespace emthrm {

int maximum_matching(const std::vector<std::vector<int>>& graph) {
  constexpr unsigned int P = 1000000007;
  using ModInt = MInt<P>;
  ModInt::set_mod(P);
  static std::mt19937_64 engine(std::random_device {} ());
  static std::uniform_int_distribution<> dist(1, P - 1);
  const int n = graph.size();
  Matrix<ModInt> tutte_matrix(n, n, 0);
  for (int i = 0; i < n; ++i) {
    for (const int j : graph[i]) {
      if (j > i) {
        const ModInt x = ModInt::raw(dist(engine));
        tutte_matrix[i][j] = x;
        tutte_matrix[j][i] = -x;
      }
    }
  }
  return gauss_jordan(&tutte_matrix, ModInt(0)) / 2;
}

}  // namespace emthrm
Back to top page