math/fps/sparse-matrix.hpp

• View this file on GitHub
• Last update: 2026-08-10 15:44:16+00:00
• Include: #include "math/fps/sparse-matrix.hpp"

Depends on

• Arbitrary Mod Convolution(任意mod畳み込み) (math/fft/arbitrary-mod-convolution.hpp)
• math/fft/fast-fourier-transform.hpp
• Formal Power Series(形式的冪級数) (math/fps/formal-power-series.hpp)

Verified with

• test/verify/yosupo-sparse-matrix-det.test.cpp

Code

#pragma once

#include <cmath>
#include <cstdint>
#include <random>
#include <utility>
#include <vector>

#include "formal-power-series.hpp"

template <typename T>
using FPSGraph = std::vector<std::vector<std::pair<int, T> > >;

template <typename T>
FormalPowerSeries<T> random_poly(int n) {
  std::mt19937 mt(1333333);
  FormalPowerSeries<T> res(n);
  std::uniform_int_distribution<int> rand(0, T::mod() - 1);
  for (int i = 0; i < n; i++) res[i] = rand(mt);
  return res;
}

template <typename T>
FormalPowerSeries<T> next_poly(const FormalPowerSeries<T>& dp,
                               const FPSGraph<T>& g) {
  const int N = (int)dp.size();
  FormalPowerSeries<T> nxt(N);
  for (int i = 0; i < N; i++) {
    for (auto& p : g[i]) nxt[p.first] += p.second * dp[i];
  }
  return nxt;
}

template <typename T>
FormalPowerSeries<T> minimum_poly(const FPSGraph<T>& g) {
  const int N = (int)g.size();
  auto dp = random_poly<T>(N), u = random_poly<T>(N);
  FormalPowerSeries<T> f(2 * N);
  for (int i = 0; i < 2 * N; i++) {
    for (auto& p : u.dot(dp)) f[i] += p;
    dp = next_poly(dp, g);
  }
  return berlekamp_massey(f);
}

/* O(N(N+S) + N std::log N std::log Q) (O(S): time complexity of nex) */
template <typename T>
FormalPowerSeries<T> sparse_pow(std::int64_t Q, FormalPowerSeries<T> dp,
                                const FPSGraph<T>& g) {
  const int N = (int)dp.size();
  auto A = FormalPowerSeries<T>({0, 1}).pow_mod(Q, minimum_poly(g));
  FormalPowerSeries<T> res(N);
  for (int i = 0; i < A.size(); i++) {
    res += dp * A[i];
    dp = next_poly(dp, g);
  }
  return res;
}

/* O(N(N+S)) (S: none-zero elements)*/
template <typename T>
T sparse_determinant(FPSGraph<T> g) {
  using FPS = FormalPowerSeries<T>;
  int N = (int)g.size();
  auto C = random_poly<T>(N);
  for (int i = 0; i < N; i++)
    for (auto& p : g[i]) p.second *= C[i];
  auto u = minimum_poly(g);
  T acdet = u[0];
  if (N % 2 == 0) acdet *= -1;
  T cdet = 1;
  for (int i = 0; i < N; i++) cdet *= C[i];
  return acdet / cdet;
}

#line 2 "math/fps/sparse-matrix.hpp"

#include <cmath>
#include <cstdint>
#include <random>
#include <utility>
#include <vector>

#line 2 "math/fps/formal-power-series.hpp"

#include <algorithm>
#include <cassert>
#line 7 "math/fps/formal-power-series.hpp"
#include <functional>
#include <iterator>
#line 11 "math/fps/formal-power-series.hpp"

#line 2 "math/fft/arbitrary-mod-convolution.hpp"

#line 5 "math/fft/arbitrary-mod-convolution.hpp"

#line 2 "math/fft/fast-fourier-transform.hpp"

#line 8 "math/fft/fast-fourier-transform.hpp"

namespace FastFourierTransform {
using real = double;

struct C {
  real x, y;

  C() : x(0), y(0) {}

  C(real x, real y) : x(x), y(y) {}

  inline C operator+(const C& c) const { return C(x + c.x, y + c.y); }

  inline C operator-(const C& c) const { return C(x - c.x, y - c.y); }

  inline C operator*(const C& c) const {
    return C(x * c.x - y * c.y, x * c.y + y * c.x);
  }

  inline C conj() const { return C(x, -y); }
};

const real PI = std::acos(-1);
int base = 1;
std::vector<C> rts = {{0, 0}, {1, 0}};
std::vector<int> rev = {0, 1};

void ensure_base(int nbase) {
  if (nbase <= base) return;
  rev.resize(1 << nbase);
  rts.resize(1 << nbase);
  for (int i = 0; i < (1 << nbase); i++) {
    rev[i] = (rev[i >> 1] >> 1) + ((i & 1) << (nbase - 1));
  }
  while (base < nbase) {
    real angle = PI * 2.0 / (1 << (base + 1));
    for (int i = 1 << (base - 1); i < (1 << base); i++) {
      rts[i << 1] = rts[i];
      real angle_i = angle * (2 * i + 1 - (1 << base));
      rts[(i << 1) + 1] = C(std::cos(angle_i), std::sin(angle_i));
    }
    ++base;
  }
}

void fft(std::vector<C>& a, int n) {
  assert((n & (n - 1)) == 0);
  int zeros = __builtin_ctz(n);
  ensure_base(zeros);
  int shift = base - zeros;
  for (int i = 0; i < n; i++) {
    if (i < (rev[i] >> shift)) {
      std::swap(a[i], a[rev[i] >> shift]);
    }
  }
  for (int k = 1; k < n; k <<= 1) {
    for (int i = 0; i < n; i += 2 * k) {
      for (int j = 0; j < k; j++) {
        C z = a[i + j + k] * rts[j + k];
        a[i + j + k] = a[i + j] - z;
        a[i + j] = a[i + j] + z;
      }
    }
  }
}

std::vector<std::int64_t> multiply(const std::vector<int>& a,
                                   const std::vector<int>& b) {
  int need = (int)a.size() + (int)b.size() - 1;
  int nbase = 1;
  while ((1 << nbase) < need) nbase++;
  ensure_base(nbase);
  int sz = 1 << nbase;
  std::vector<C> fa(sz);
  for (int i = 0; i < sz; i++) {
    int x = (i < (int)a.size() ? a[i] : 0);
    int y = (i < (int)b.size() ? b[i] : 0);
    fa[i] = C(x, y);
  }
  fft(fa, sz);
  C r(0, -0.25 / (sz >> 1)), s(0, 1), t(0.5, 0);
  for (int i = 0; i <= (sz >> 1); i++) {
    int j = (sz - i) & (sz - 1);
    C z = (fa[j] * fa[j] - (fa[i] * fa[i]).conj()) * r;
    fa[j] = (fa[i] * fa[i] - (fa[j] * fa[j]).conj()) * r;
    fa[i] = z;
  }
  for (int i = 0; i < (sz >> 1); i++) {
    C A0 = (fa[i] + fa[i + (sz >> 1)]) * t;
    C A1 = (fa[i] - fa[i + (sz >> 1)]) * t * rts[(sz >> 1) + i];
    fa[i] = A0 + A1 * s;
  }
  fft(fa, sz >> 1);
  std::vector<std::int64_t> ret(need);
  for (int i = 0; i < need; i++) {
    ret[i] = std::llround(i & 1 ? fa[i >> 1].y : fa[i >> 1].x);
  }
  return ret;
}
};  // namespace FastFourierTransform
#line 7 "math/fft/arbitrary-mod-convolution.hpp"

/*
 * @brief Arbitrary Mod Convolution(任意mod畳み込み)
 */
template <typename T>
struct ArbitraryModConvolution {
  using real = FastFourierTransform::real;
  using C = FastFourierTransform::C;

  ArbitraryModConvolution() = default;

  static std::vector<T> multiply(const std::vector<T>& a,
                                 const std::vector<T>& b, int need = -1) {
    if (need == -1) need = a.size() + b.size() - 1;
    int nbase = 0;
    while ((1 << nbase) < need) nbase++;
    FastFourierTransform::ensure_base(nbase);
    int sz = 1 << nbase;
    std::vector<C> fa(sz);
    for (int i = 0; i < a.size(); i++) {
      fa[i] = C(a[i].val() & ((1 << 15) - 1), a[i].val() >> 15);
    }
    fft(fa, sz);
    std::vector<C> fb(sz);
    if (a == b) {
      fb = fa;
    } else {
      for (int i = 0; i < b.size(); i++) {
        fb[i] = C(b[i].val() & ((1 << 15) - 1), b[i].val() >> 15);
      }
      fft(fb, sz);
    }
    real ratio = 0.25 / sz;
    C r2(0, -1), r3(ratio, 0), r4(0, -ratio), r5(0, 1);
    for (int i = 0; i <= (sz >> 1); i++) {
      int j = (sz - i) & (sz - 1);
      C a1 = (fa[i] + fa[j].conj());
      C a2 = (fa[i] - fa[j].conj()) * r2;
      C b1 = (fb[i] + fb[j].conj()) * r3;
      C b2 = (fb[i] - fb[j].conj()) * r4;
      if (i != j) {
        C c1 = (fa[j] + fa[i].conj());
        C c2 = (fa[j] - fa[i].conj()) * r2;
        C d1 = (fb[j] + fb[i].conj()) * r3;
        C d2 = (fb[j] - fb[i].conj()) * r4;
        fa[i] = c1 * d1 + c2 * d2 * r5;
        fb[i] = c1 * d2 + c2 * d1;
      }
      fa[j] = a1 * b1 + a2 * b2 * r5;
      fb[j] = a1 * b2 + a2 * b1;
    }
    fft(fa, sz);
    fft(fb, sz);
    std::vector<T> ret(need);
    for (int i = 0; i < need; i++) {
      std::int64_t aa = std::llround(fa[i].x);
      std::int64_t bb = std::llround(fb[i].x);
      std::int64_t cc = std::llround(fa[i].y);
      aa = T(aa).val(), bb = T(bb).val(), cc = T(cc).val();
      ret[i] = aa + (bb << 15) + (cc << 30);
    }
    return ret;
  }
};
#line 13 "math/fps/formal-power-series.hpp"

/**
 * @brief Formal Power Series(形式的冪級数)
 */
template <typename T>
struct FormalPowerSeries : std::vector<T> {
  using std::vector<T>::vector;
  using P = FormalPowerSeries;
  using Conv = ArbitraryModConvolution<T>;

  P pre(int deg) const {
    return P(std::begin(*this),
             std::begin(*this) + std::min((int)this->size(), deg));
  }

  P rev(int deg = -1) const {
    P ret(*this);
    if (deg != -1) ret.resize(deg, T(0));
    std::reverse(std::begin(ret), std::end(ret));
    return ret;
  }

  void shrink() {
    while (this->size() && this->back() == T(0)) this->pop_back();
  }

  P operator+(const P& r) const { return P(*this) += r; }

  P operator+(const T& v) const { return P(*this) += v; }

  P operator-(const P& r) const { return P(*this) -= r; }

  P operator-(const T& v) const { return P(*this) -= v; }

  P operator*(const P& r) const { return P(*this) *= r; }

  P operator*(const T& v) const { return P(*this) *= v; }

  P operator/(const P& r) const { return P(*this) /= r; }

  P operator%(const P& r) const { return P(*this) %= r; }

  P& operator+=(const P& r) {
    if (r.size() > this->size()) this->resize(r.size());
    for (int i = 0; i < r.size(); i++) (*this)[i] += r[i];
    return *this;
  }

  P& operator-=(const P& r) {
    if (r.size() > this->size()) this->resize(r.size());
    for (int i = 0; i < r.size(); i++) (*this)[i] -= r[i];
    return *this;
  }

  // https://judge.yosupo.jp/problem/convolution_mod
  P& operator*=(const P& r) {
    if (this->empty() || r.empty()) {
      this->clear();
      return *this;
    }
    auto ret = Conv::multiply(*this, r);
    return *this = {std::begin(ret), std::end(ret)};
  }

  P& operator/=(const P& r) {
    if (this->size() < r.size()) {
      this->clear();
      return *this;
    }
    int n = this->size() - r.size() + 1;
    return *this = (rev().pre(n) * r.rev().inv(n)).pre(n).rev(n);
  }

  P& operator%=(const P& r) { return *this -= *this / r * r; }

  // https://judge.yosupo.jp/problem/division_of_polynomials
  std::pair<P, P> div_mod(const P& r) {
    P q = *this / r;
    return std::make_pair(q, *this - q * r);
  }

  P operator-() const {
    P ret(this->size());
    for (int i = 0; i < this->size(); i++) ret[i] = -(*this)[i];
    return ret;
  }

  P& operator+=(const T& r) {
    if (this->empty()) this->resize(1);
    (*this)[0] += r;
    return *this;
  }

  P& operator-=(const T& r) {
    if (this->empty()) this->resize(1);
    (*this)[0] -= r;
    return *this;
  }

  P& operator*=(const T& v) {
    for (int i = 0; i < this->size(); i++) (*this)[i] *= v;
    return *this;
  }

  P dot(P r) const {
    P ret(std::min(this->size(), r.size()));
    for (int i = 0; i < ret.size(); i++) ret[i] = (*this)[i] * r[i];
    return ret;
  }

  P operator>>(int sz) const {
    if (this->size() <= sz) return {};
    P ret(*this);
    ret.erase(ret.begin(), ret.begin() + sz);
    return ret;
  }

  P operator<<(int sz) const {
    P ret(*this);
    ret.insert(ret.begin(), sz, T(0));
    return ret;
  }

  T operator()(T x) const {
    T r = 0, w = 1;
    for (auto& v : *this) {
      r += w * v;
      w *= x;
    }
    return r;
  }

  P diff() const {
    const int n = (int)this->size();
    P ret(std::max(0, n - 1));
    for (int i = 1; i < n; i++) ret[i - 1] = (*this)[i] * T(i);
    return ret;
  }

  P integral() const {
    const int n = (int)this->size();
    P ret(n + 1);
    ret[0] = T(0);
    for (int i = 0; i < n; i++) ret[i + 1] = (*this)[i] / T(i + 1);
    return ret;
  }

  // https://judge.yosupo.jp/problem/inv_of_formal_power_series
  // F(0) must not be 0
  P inv(int deg = -1) const {
    assert(((*this)[0]) != T(0));
    const int n = (int)this->size();
    if (deg == -1) deg = n;
    P ret({T(1) / (*this)[0]});
    for (int i = 1; i < deg; i <<= 1) {
      ret = (ret + ret - ret * ret * pre(i << 1)).pre(i << 1);
    }
    return ret.pre(deg);
  }

  // https://judge.yosupo.jp/problem/log_of_formal_power_series
  // F(0) must be 1
  P log(int deg = -1) const {
    assert((*this)[0] == T(1));
    const int n = (int)this->size();
    if (deg == -1) deg = n;
    return (this->diff() * this->inv(deg)).pre(deg - 1).integral();
  }

  // https://judge.yosupo.jp/problem/sqrt_of_formal_power_series
  P sqrt(
      int deg = -1,
      const std::function<T(T)>& get_sqrt = [](T) { return T(1); }) const {
    const int n = (int)this->size();
    if (deg == -1) deg = n;
    if ((*this)[0] == T(0)) {
      for (int i = 1; i < n; i++) {
        if ((*this)[i] != T(0)) {
          if (i & 1) return {};
          if (deg - i / 2 <= 0) break;
          auto ret = (*this >> i).sqrt(deg - i / 2, get_sqrt);
          if (ret.empty()) return {};
          ret = ret << (i / 2);
          if (ret.size() < deg) ret.resize(deg, T(0));
          return ret;
        }
      }
      return P(deg, 0);
    }
    auto sqr = T(get_sqrt((*this)[0]));
    if (sqr * sqr != (*this)[0]) return {};
    P ret{sqr};
    T inv2 = T(1) / T(2);
    for (int i = 1; i < deg; i <<= 1) {
      ret = (ret + pre(i << 1) * ret.inv(i << 1)) * inv2;
    }
    return ret.pre(deg);
  }

  P sqrt(const std::function<T(T)>& get_sqrt, int deg = -1) const {
    return sqrt(deg, get_sqrt);
  }

  // https://judge.yosupo.jp/problem/exp_of_formal_power_series
  // F(0) must be 0
  P exp(int deg = -1) const {
    if (deg == -1) deg = this->size();
    assert((*this)[0] == T(0));
    const int n = (int)this->size();
    if (deg == -1) deg = n;
    P ret({T(1)});
    for (int i = 1; i < deg; i <<= 1) {
      ret = (ret * (pre(i << 1) + T(1) - ret.log(i << 1))).pre(i << 1);
    }
    return ret.pre(deg);
  }

  // https://judge.yosupo.jp/problem/pow_of_formal_power_series
  P pow(std::int64_t k, int deg = -1) const {
    const int n = (int)this->size();
    if (deg == -1) deg = n;
    if (k == 0) {
      P ret(deg, T(0));
      ret[0] = T(1);
      return ret;
    }
    for (int i = 0; i < n; i++) {
      if (i * k > deg) return P(deg, T(0));
      if ((*this)[i] != T(0)) {
        T rev = T(1) / (*this)[i];
        P ret = (((*this * rev) >> i).log() * k).exp() * ((*this)[i].pow(k));
        ret = (ret << (i * k)).pre(deg);
        if (ret.size() < deg) ret.resize(deg, T(0));
        return ret;
      }
    }
    return *this;
  }

  // https://yukicoder.me/problems/no/215
  P mod_pow(std::int64_t k, P g) const {
    P modinv = g.rev().inv();
    auto get_div = [&](P base) {
      if (base.size() < g.size()) {
        base.clear();
        return base;
      }
      int n = base.size() - g.size() + 1;
      return (base.rev().pre(n) * modinv.pre(n)).pre(n).rev(n);
    };
    P x(*this), ret{1};
    while (k > 0) {
      if (k & 1) {
        ret *= x;
        ret -= get_div(ret) * g;
        ret.shrink();
      }
      x *= x;
      x -= get_div(x) * g;
      x.shrink();
      k >>= 1;
    }
    return ret;
  }

  // https://judge.yosupo.jp/problem/polynomial_taylor_shift
  P taylor_shift(T c) const {
    int n = (int)this->size();
    std::vector<T> fact(n), rfact(n);
    fact[0] = rfact[0] = T(1);
    for (int i = 1; i < n; i++) fact[i] = fact[i - 1] * T(i);
    rfact[n - 1] = T(1) / fact[n - 1];
    for (int i = n - 1; i > 1; i--) rfact[i - 1] = rfact[i] * T(i);
    P p(*this);
    for (int i = 0; i < n; i++) p[i] *= fact[i];
    p = p.rev();
    P bs(n, T(1));
    for (int i = 1; i < n; i++) bs[i] = bs[i - 1] * c * rfact[i] * fact[i - 1];
    p = (p * bs).pre(n);
    p = p.rev();
    for (int i = 0; i < n; i++) p[i] *= rfact[i];
    return p;
  }
};

template <typename Mint>
using FPS = FormalPowerSeries<Mint>;
#line 10 "math/fps/sparse-matrix.hpp"

template <typename T>
using FPSGraph = std::vector<std::vector<std::pair<int, T> > >;

template <typename T>
FormalPowerSeries<T> random_poly(int n) {
  std::mt19937 mt(1333333);
  FormalPowerSeries<T> res(n);
  std::uniform_int_distribution<int> rand(0, T::mod() - 1);
  for (int i = 0; i < n; i++) res[i] = rand(mt);
  return res;
}

template <typename T>
FormalPowerSeries<T> next_poly(const FormalPowerSeries<T>& dp,
                               const FPSGraph<T>& g) {
  const int N = (int)dp.size();
  FormalPowerSeries<T> nxt(N);
  for (int i = 0; i < N; i++) {
    for (auto& p : g[i]) nxt[p.first] += p.second * dp[i];
  }
  return nxt;
}

template <typename T>
FormalPowerSeries<T> minimum_poly(const FPSGraph<T>& g) {
  const int N = (int)g.size();
  auto dp = random_poly<T>(N), u = random_poly<T>(N);
  FormalPowerSeries<T> f(2 * N);
  for (int i = 0; i < 2 * N; i++) {
    for (auto& p : u.dot(dp)) f[i] += p;
    dp = next_poly(dp, g);
  }
  return berlekamp_massey(f);
}

/* O(N(N+S) + N std::log N std::log Q) (O(S): time complexity of nex) */
template <typename T>
FormalPowerSeries<T> sparse_pow(std::int64_t Q, FormalPowerSeries<T> dp,
                                const FPSGraph<T>& g) {
  const int N = (int)dp.size();
  auto A = FormalPowerSeries<T>({0, 1}).pow_mod(Q, minimum_poly(g));
  FormalPowerSeries<T> res(N);
  for (int i = 0; i < A.size(); i++) {
    res += dp * A[i];
    dp = next_poly(dp, g);
  }
  return res;
}

/* O(N(N+S)) (S: none-zero elements)*/
template <typename T>
T sparse_determinant(FPSGraph<T> g) {
  using FPS = FormalPowerSeries<T>;
  int N = (int)g.size();
  auto C = random_poly<T>(N);
  for (int i = 0; i < N; i++)
    for (auto& p : g[i]) p.second *= C[i];
  auto u = minimum_poly(g);
  T acdet = u[0];
  if (N % 2 == 0) acdet *= -1;
  T cdet = 1;
  for (int i = 0; i < N; i++) cdet *= C[i];
  return acdet / cdet;
}

Back to top page