有名数列
(fps/famous-sequences.hpp)

View this file on GitHub
Last update: 2025-11-06 12:30:44+09:00
Include: #include "fps/famous-sequences.hpp"

分割数

非負整数 $n$ の分割数 $p_n$ とは，$n$ をいくつかの正整数の和（順序を区別しない）で表す方法の数．

母関数は $\prod_{k=1}^{\infty}\frac{1}{1-x^k}$ である．

オイラーの五角数定理より $\prod_{k=1}^{\infty}(1-x^k)=\sum_{k=-\infty}^{\infty}(-1)^kx^{k(3k-1)/2}$ であることを用いれば $O(N\log N)$ 時間で $p_0,p_1,\dots,p_N$ が列挙できる．

ベル数

$n$ 元集合を空でない部分集合に分割する方法の数 $B_n$ をベル数という．指数型母関数が下のように計算できる． $\sum_{n}\frac{B_n}{n!}x^n =\prod_{i=1}^{\infty}\sum_{j=0}^{\infty}\frac{1}{(i!)^jj!}x^{ij} =\prod_{i=1}^{\infty}\exp\left(\frac{x^i}{i!}\right) =\exp\left(\sum_{i=1}^{\infty}\frac{x^i}{i!}\right) =\exp(e^x-1)$

モンモール数

長さ $n$ の撹乱順列，すなわち $(1,2,\dots,n)$ の順列 $(p_1,p_2,\dots,p_n)$ で $p_i\neq i$ を満たすものの個数．

$a_n$ とおくと $a_n=(n-1)(a_{n-1}+a_{n-2})$ であるから $O(n)$ 時間で列挙できる．

第一種スターリング数

$s(n,k)$ を以下で定める． $x(x-1)\cdots(x-(n-1))=\sum_{k=0}^{n}s(n,k)x^k$

$s(n,i)$ の $0\leq i\leq n$ での列挙が $O(n\log n)$ 時間でできる．

分割統治をするが，一方の結果を Taylor Shift すればもう一方の結果を得られる．

また $\sum_{i,j}s(i,j)\frac{x^i}{i!}y^j=(1+x)^y=\exp(y\log(1+x))=\sum_{j}(\log(1+x))^j\frac{y^j}{j!}$ となるので $s(i,k)$ の $k\leq i\leq n$ での列挙が $O((n-k)\log (n-k))$ 時間でできる．

第二種スターリング数

$S(n,k)$ を以下で定める． $x^n=\sum_{k=0}^{n}S(n,k)x(x-1)\cdots(x-(k-1))$

整数 $i$ について $x=i$ としたとき $i^n=i![y^i]\left(\sum_{k=0}^{n}S(n,k)y^k\right)e^y$ と表示できるので $\sum_{k=0}^{n}S(n,k)y^k=e^{-y}\left(\sum_{i=0}^{\infty}\frac{i^n}{i!}y^i\right)$ であり，$S(n,i)$ の $0\leq i\leq n$ での列挙が $O(n\log n)$ 時間でできる．また $\sum_{i=0}^{\infty}\frac{i^n}{i!}y^i=n![x^n]\sum_{i=0}^{\infty}\frac{e^{ix}}{i!}y^i=n![x^n]\exp(e^xy)$ より $\sum_{n,k}S(n,k)\frac{x^n}{n!}y^k=\exp((e^x-1)y)=\sum_{i\geq 0}(e^x-1)^i\frac{y^i}{i!}$ となるので $S(i,k)$ の $k\leq i\leq n$ での列挙が $O((n-k)\log (n-k))$ 時間でできる．

Depends on

Verified with

Code

#pragma once
#include "modint/factorial.hpp"
#include "modint/power-table.hpp"
#include "fps/formal-power-series.hpp"
#include "fps/taylor-shift.hpp"

template <class mint>
FormalPowerSeries<mint> PartitionFunction(int n) {
  FormalPowerSeries<mint> g(n + 1);
  for (int k = 0; k * (3 * k - 1) / 2 <= n; k++) g[k * (3 * k - 1) / 2] += k & 1 ? -1 : 1;
  for (int k = 1; k * (3 * k + 1) / 2 <= n; k++) g[k * (3 * k + 1) / 2] += k & 1 ? -1 : 1;
  return g.inv(n + 1);
}
template <class mint>
FormalPowerSeries<mint> BellNumber(int n) {
  using fact = Factorial<mint>;
  FormalPowerSeries<mint> f(n + 1);
  for (int i = 1; i < f.size(); i++) f[i] = fact::fact_inv(i);
  f = f.exp();
  for (int i = 0; i < f.size(); i++) f[i] *= fact::fact(i);
  return f;
}
template <class mint>
vector<mint> MontmortNumber(int n) {
  vector<mint> f(n + 1);
  f[0] = 1, f[1] = 0;
  for (int i = 2; i < f.size(); i++) f[i] = (i - 1) * (f[i - 1] + f[i - 2]);
  return f;
}
template <class mint>
FormalPowerSeries<mint> FirstKindStirlingNumbers(int n) {
  FormalPowerSeries<mint> f{1};
  for (int l = 30; l >= 0; l--) {
    if (f.size() > 1) f *= TaylorShift(f, mint(-(n >> (l + 1))));
    if ((n >> l) & 1) f = (f << 1) - f * mint((n >> l) - 1);
  }
  return f;
}
template <class mint>
FormalPowerSeries<mint> FirstKindStirlingNumbersFixedK(int n, int k) {
  using fact = Factorial<mint>;
  if (k > n) return FormalPowerSeries<mint>{};
  FormalPowerSeries<mint> f(n - k + 1);
  for (int i = 0; i < f.size(); i++) f[i] = fact::inv(i + 1) * (i & 1 ? -1 : 1);
  f = f.pow(k);
  f *= fact::fact_inv(k);
  for (int i = 0; i < f.size(); i++) f[i] *= fact::fact(i + k);
  return f;
}
template <class mint>
FormalPowerSeries<mint> SecondKindStirlingNumbers(int n) {
  using fact = Factorial<mint>;
  FormalPowerSeries<mint> f(n + 1);
  for (int i = 0; i < f.size(); i++) f[i] = fact::fact_inv(i) * (i & 1 ? -1 : 1);
  FormalPowerSeries<mint> g(PowerTable<mint>(n, n));
  for (int i = 0; i < g.size(); i++) g[i] *= fact::fact_inv(i);
  f *= g;
  f.resize(n + 1);
  return f;
}
template <class mint>
FormalPowerSeries<mint> SecondKindStirlingNumbersFixedK(int n, int k) {
  using fact = Factorial<mint>;
  if (k > n) return FormalPowerSeries<mint>{};
  FormalPowerSeries<mint> f(n - k + 1);
  for (int i = 0; i < f.size(); i++) f[i] = fact::fact_inv(i + 1);
  f = f.pow(k);
  f *= fact::fact_inv(k);
  for (int i = 0; i < f.size(); i++) f[i] *= fact::fact(i + k);
  return f;
}

/**
 * @brief 有名数列
 * @docs docs/fps/famous-sequences.md
 */

#line 2 "modint/factorial.hpp"

template <class mint>
struct Factorial {
  static void reserve(int n) {
    inv(n);
    fact(n);
    fact_inv(n);
  }
  static mint inv(int n) {
    static long long mod = mint::get_mod();
    static vector<mint> buf({0, 1});
    assert(n != 0);
    if (mod != mint::get_mod()) {
      mod = mint::get_mod();
      buf = vector<mint>({0, 1});
    }
    while ((int)buf.capacity() <= n) buf.reserve(buf.capacity() * 2);
    while ((int)buf.size() <= n) {
      long long k = buf.size(), q = (mod + k - 1) / k;
      buf.push_back(q * buf[k * q - mod]);
    }
    return buf[n];
  }
  static mint fact(int n) {
    static long long mod = mint::get_mod();
    static vector<mint> buf({1, 1});
    assert(n >= 0);
    if (mod != mint::get_mod()) {
      mod = mint::get_mod();
      buf = vector<mint>({1, 1});
    }
    while ((int)buf.capacity() <= n) buf.reserve(buf.capacity() * 2);
    while ((int)buf.size() <= n) {
      long long k = buf.size();
      buf.push_back(buf.back() * k);
    }
    return buf[n];
  }
  static mint fact_inv(int n) {
    static long long mod = mint::get_mod();
    static vector<mint> buf({1, 1});
    assert(n >= 0);
    if (mod != mint::get_mod()) {
      mod = mint::get_mod();
      buf = vector<mint>({1, 1});
    }
    if ((int)buf.size() <= n) inv(n);
    while ((int)buf.capacity() <= n) buf.reserve(buf.capacity() * 2);
    while ((int)buf.size() <= n) {
      long long k = buf.size();
      buf.push_back(buf.back() * inv(k));
    }
    return buf[n];
  }
  static mint binom(int n, int r) {
    if (r < 0 || r > n) return 0;
    return fact(n) * fact_inv(r) * fact_inv(n - r);
  }
  static mint binom_naive(int n, int r) {
    if (r < 0 || r > n) return 0;
    mint res = fact_inv(r);
    for (int i = 0; i < r; i++) res *= n - i;
    return res;
  }
  static mint multinom(const vector<int>& r) {
    int n = 0;
    for (auto& x : r) {
      if (x < 0) return 0;
      n += x;
    }
    mint res = fact(n);
    for (auto& x : r) res *= fact_inv(x);
    return res;
  }
  static mint P(int n, int r) {
    if (r < 0 || r > n) return 0;
    return fact(n) * fact_inv(n - r);
  }
  // partition n items to r groups (allow empty group)
  static mint H(int n, int r) {
    if (n < 0 || r < 0) return 0;
    return r == 0 ? 1 : binom(n + r - 1, r);
  }
};
/**
 * @brief 階乗, 二項係数
 */
#line 2 "math/lpf-table.hpp"

vector<int> LPFTable(int n) {
  vector<int> lpf(n + 1, 0);
  iota(lpf.begin(), lpf.end(), 0);
  for (int p = 2; p * p <= n; p += (p & 1) + 1) {
    if (lpf[p] != p) continue;
    for (int i = p * p; i <= n; i += p)
      if (lpf[i] == i) lpf[i] = p;
  }
  return lpf;
}
/**
 * @brief LPF Table
 */
#line 3 "modint/power-table.hpp"

// 0^k,1^k,2^k,...,n^k
template <class T>
vector<T> PowerTable(int n, int k) {
  assert(k >= 0);
  vector<T> f;
  if (k == 0) {
    f = vector<T>(n + 1, 0);
    f[0] = 1;
  } else {
    f = vector<T>(n + 1, 1);
    f[0] = 0;
    auto lpf = LPFTable(n);
    for (int i = 2; i <= n; i++)
      f[i] = lpf[i] == i ? T(i).pow(k) : f[i / lpf[i]] * f[lpf[i]];
  }
  return f;
}
/**
 * @brief Power Table
 */
#line 2 "fps/formal-power-series.hpp"

template <class mint>
struct FormalPowerSeries : vector<mint> {
  using vector<mint>::vector;
  using FPS = FormalPowerSeries;
  FormalPowerSeries(const vector<mint>& r) : vector<mint>(r) {}
  FormalPowerSeries(vector<mint>&& r) : vector<mint>(std::move(r)) {}
  FPS& operator=(const vector<mint>& r) {
    vector<mint>::operator=(r);
    return *this;
  }
  FPS& operator+=(const FPS& r) {
    if (r.size() > this->size()) this->resize(r.size());
    for (int i = 0; i < (int)r.size(); i++) (*this)[i] += r[i];
    return *this;
  }
  FPS& operator+=(const mint& r) {
    if (this->empty()) this->resize(1);
    (*this)[0] += r;
    return *this;
  }
  FPS& operator-=(const FPS& r) {
    if (r.size() > this->size()) this->resize(r.size());
    for (int i = 0; i < (int)r.size(); i++) (*this)[i] -= r[i];
    return *this;
  }
  FPS& operator-=(const mint& r) {
    if (this->empty()) this->resize(1);
    (*this)[0] -= r;
    return *this;
  }
  FPS& operator*=(const mint& v) {
    for (int k = 0; k < (int)this->size(); k++) (*this)[k] *= v;
    return *this;
  }
  FPS& operator/=(const FPS& r) {
    if (this->size() < r.size()) {
      this->clear();
      return *this;
    }
    int n = this->size() - r.size() + 1;
    if ((int)r.size() <= 64) {
      FPS f(*this), g(r);
      g.shrink();
      mint coeff = g.at(g.size() - 1).inv();
      for (auto& x : g) x *= coeff;
      int deg = (int)f.size() - (int)g.size() + 1;
      int gs = g.size();
      FPS quo(deg);
      for (int i = deg - 1; i >= 0; i--) {
        quo[i] = f[i + gs - 1];
        for (int j = 0; j < gs; j++) f[i + j] -= quo[i] * g[j];
      }
      *this = quo * coeff;
      this->resize(n, mint(0));
      return *this;
    }
    return *this = ((*this).rev().pre(n) * r.rev().inv(n)).pre(n).rev();
  }
  FPS& operator%=(const FPS& r) {
    *this -= *this / r * r;
    shrink();
    return *this;
  }
  FPS operator+(const FPS& r) const { return FPS(*this) += r; }
  FPS operator+(const mint& v) const { return FPS(*this) += v; }
  FPS operator-(const FPS& r) const { return FPS(*this) -= r; }
  FPS operator-(const mint& v) const { return FPS(*this) -= v; }
  FPS operator*(const FPS& r) const { return FPS(*this) *= r; }
  FPS operator*(const mint& v) const { return FPS(*this) *= v; }
  FPS operator/(const FPS& r) const { return FPS(*this) /= r; }
  FPS operator%(const FPS& r) const { return FPS(*this) %= r; }
  FPS operator-() const {
    FPS ret(this->size());
    for (int i = 0; i < (int)this->size(); i++) ret[i] = -(*this)[i];
    return ret;
  }
  void shrink() {
    while (this->size() && this->back() == mint(0)) this->pop_back();
  }
  FPS rev() const {
    FPS ret(*this);
    reverse(begin(ret), end(ret));
    return ret;
  }
  FPS dot(FPS r) const {
    FPS ret(min(this->size(), r.size()));
    for (int i = 0; i < (int)ret.size(); i++) ret[i] = (*this)[i] * r[i];
    return ret;
  }
  FPS pre(int sz) const {
    return FPS(begin(*this), begin(*this) + min((int)this->size(), sz));
  }
  FPS operator>>=(int sz) {
    assert(sz >= 0);
    if ((int)this->size() <= sz)
      this->clear();
    else
      this->erase(this->begin(), this->begin() + sz);
    return *this;
  }
  FPS operator>>(int sz) const {
    if ((int)this->size() <= sz) return {};
    FPS ret(*this);
    ret.erase(ret.begin(), ret.begin() + sz);
    return ret;
  }
  FPS operator<<=(int sz) {
    assert(sz >= 0);
    this->insert(this->begin(), sz, mint(0));
    return *this;
  }
  FPS operator<<(int sz) const {
    FPS ret(*this);
    ret.insert(ret.begin(), sz, mint(0));
    return ret;
  }
  FPS diff() const {
    const int n = (int)this->size();
    FPS ret(max(0, n - 1));
    mint one(1), coeff(1);
    for (int i = 1; i < n; i++) {
      ret[i - 1] = (*this)[i] * coeff;
      coeff += one;
    }
    return ret;
  }
  FPS integral() const {
    const int n = (int)this->size();
    FPS ret(n + 1);
    ret[0] = mint(0);
    if (n > 0) ret[1] = mint(1);
    auto mod = mint::get_mod();
    for (int i = 2; i <= n; i++) ret[i] = (-ret[mod % i]) * (mod / i);
    for (int i = 0; i < n; i++) ret[i + 1] *= (*this)[i];
    return ret;
  }
  mint eval(mint x) const {
    mint r = 0, w = 1;
    for (auto& v : *this) r += w * v, w *= x;
    return r;
  }
  FPS log(int deg = -1) const {
    assert((*this)[0] == mint(1));
    if (deg == -1) deg = (int)this->size();
    return (this->diff() * this->inv(deg)).pre(deg - 1).integral();
  }
  FPS pow(int64_t k, int deg = -1) const {
    const int n = (int)this->size();
    if (deg == -1) deg = n;
    if (k == 0) {
      FPS ret(deg);
      if (deg) ret[0] = 1;
      return ret;
    }
    for (int i = 0; i < n; i++) {
      if ((*this)[i] != mint(0)) {
        mint rev = mint(1) / (*this)[i];
        FPS ret = (((*this * rev) >> i).log(deg) * k).exp(deg);
        ret *= (*this)[i].pow(k);
        ret = (ret << (i * k)).pre(deg);
        if ((int)ret.size() < deg) ret.resize(deg, mint(0));
        return ret;
      }
      if (__int128_t(i + 1) * k >= deg) return FPS(deg, mint(0));
    }
    return FPS(deg, mint(0));
  }

  static void* ntt_ptr;
  static void set_ntt();
  FPS& operator*=(const FPS& r);
  FPS middle_product(const FPS& r) const;
  void ntt();
  void intt();
  void ntt_doubling();
  static int ntt_root();
  FPS inv(int deg = -1) const;
  FPS exp(int deg = -1) const;
};
template <typename mint>
void* FormalPowerSeries<mint>::ntt_ptr = nullptr;
#line 4 "fps/taylor-shift.hpp"

// f(x+a)
template <class mint>
FormalPowerSeries<mint> TaylorShift(FormalPowerSeries<mint> f, mint a) {
  using fps = FormalPowerSeries<mint>;
  int n = f.size();
  using fact = Factorial<mint>;
  fact::reserve(n);
  for (int i = 0; i < n; i++) f[i] *= fact::fact(i);
  reverse(f.begin(), f.end());
  fps g(n, mint(1));
  for (int i = 1; i < n; i++) g[i] = g[i - 1] * a * fact::inv(i);
  f = (f * g).pre(n);
  reverse(f.begin(), f.end());
  for (int i = 0; i < n; i++) f[i] *= fact::fact_inv(i);
  return f;
}
/**
 * @brief Taylor Shift
 * @docs docs/fps/taylor-shift.md
 */
#line 6 "fps/famous-sequences.hpp"

template <class mint>
FormalPowerSeries<mint> PartitionFunction(int n) {
  FormalPowerSeries<mint> g(n + 1);
  for (int k = 0; k * (3 * k - 1) / 2 <= n; k++) g[k * (3 * k - 1) / 2] += k & 1 ? -1 : 1;
  for (int k = 1; k * (3 * k + 1) / 2 <= n; k++) g[k * (3 * k + 1) / 2] += k & 1 ? -1 : 1;
  return g.inv(n + 1);
}
template <class mint>
FormalPowerSeries<mint> BellNumber(int n) {
  using fact = Factorial<mint>;
  FormalPowerSeries<mint> f(n + 1);
  for (int i = 1; i < f.size(); i++) f[i] = fact::fact_inv(i);
  f = f.exp();
  for (int i = 0; i < f.size(); i++) f[i] *= fact::fact(i);
  return f;
}
template <class mint>
vector<mint> MontmortNumber(int n) {
  vector<mint> f(n + 1);
  f[0] = 1, f[1] = 0;
  for (int i = 2; i < f.size(); i++) f[i] = (i - 1) * (f[i - 1] + f[i - 2]);
  return f;
}
template <class mint>
FormalPowerSeries<mint> FirstKindStirlingNumbers(int n) {
  FormalPowerSeries<mint> f{1};
  for (int l = 30; l >= 0; l--) {
    if (f.size() > 1) f *= TaylorShift(f, mint(-(n >> (l + 1))));
    if ((n >> l) & 1) f = (f << 1) - f * mint((n >> l) - 1);
  }
  return f;
}
template <class mint>
FormalPowerSeries<mint> FirstKindStirlingNumbersFixedK(int n, int k) {
  using fact = Factorial<mint>;
  if (k > n) return FormalPowerSeries<mint>{};
  FormalPowerSeries<mint> f(n - k + 1);
  for (int i = 0; i < f.size(); i++) f[i] = fact::inv(i + 1) * (i & 1 ? -1 : 1);
  f = f.pow(k);
  f *= fact::fact_inv(k);
  for (int i = 0; i < f.size(); i++) f[i] *= fact::fact(i + k);
  return f;
}
template <class mint>
FormalPowerSeries<mint> SecondKindStirlingNumbers(int n) {
  using fact = Factorial<mint>;
  FormalPowerSeries<mint> f(n + 1);
  for (int i = 0; i < f.size(); i++) f[i] = fact::fact_inv(i) * (i & 1 ? -1 : 1);
  FormalPowerSeries<mint> g(PowerTable<mint>(n, n));
  for (int i = 0; i < g.size(); i++) g[i] *= fact::fact_inv(i);
  f *= g;
  f.resize(n + 1);
  return f;
}
template <class mint>
FormalPowerSeries<mint> SecondKindStirlingNumbersFixedK(int n, int k) {
  using fact = Factorial<mint>;
  if (k > n) return FormalPowerSeries<mint>{};
  FormalPowerSeries<mint> f(n - k + 1);
  for (int i = 0; i < f.size(); i++) f[i] = fact::fact_inv(i + 1);
  f = f.pow(k);
  f *= fact::fact_inv(k);
  for (int i = 0; i < f.size(); i++) f[i] *= fact::fact(i + k);
  return f;
}

/**
 * @brief 有名数列
 * @docs docs/fps/famous-sequences.md
 */

有名数列 (fps/famous-sequences.hpp)

分割数

ベル数