競技プログラミング用 C++ ライブラリ
math/binomial_prefix_sum_incremental.hpp · GitHub で見る
全体サイト(256 KiB向け) · 高速実装
\(\displaystyle S(n,k)=\sum_{i=0}^{k-1}\binom ni\) を、直前のクエリから差分更新して求めます。右端を含みません。クエリは呼び出した順に処理します。
#include "lib/math/binomial_prefix_sum_incremental.hpp"
IncrementalBinomialPrefixSum<> sum(500000);
auto other = sum;
auto a = sum.query(5, 3); // 16
auto b = sum.query(6, 3); // 22
auto c = sum.query(6, 4); // 42
auto d = other.query(5, 2); // 6
auto e = sum.binom(5, 2); // 10
| 操作 | 内容・返り値 | 計算量 |
|---|---|---|
IncrementalBinomialPrefixSum<Mint>(max_n) |
上限まで前計算。省略時は 0 | \(O(N)\) |
auto other = sum / other = sum
|
表を共有し、現在のクエリ状態をコピー。その後の状態は独立 | \(O(1)\) |
build(max_n) |
このオブジェクトだけ表を作り直し、状態を初期化 | \(O(N)\) |
max_n() |
前計算の上限 | \(O(1)\) |
query(n,k) |
\(\displaystyle\sum_{i=0}^{k-1}\binom ni\)。右端を含まない | \(O(\lvert\Delta n\rvert+\lvert\Delta k\rvert)\) |
binom(n,k) |
\(\displaystyle\binom nk\) を Mint で返す。n < 0、k < 0、n < k なら 0 |
\(O(1)\) |
Mint の既定は mint です。素数 mod の mod()・inv() と整数からの構築・加減乗算に対応する modint を指定できます。query の n は 0 以上 max_n 以下、max_n は非負で mod()・INT_MAX 未満とし、使用中に法を変更しないでください。k は std::int64_t で、内部で \([0,n+1]\) に切り詰めます。k <= 0 なら 0、k >= n+1 なら 2^n を Mint で返します。binom も、0 を返す範囲外引数を除き n <= max_n() とします。
build(max_n) は前計算と状態を作り直し、max_n() は前計算の上限を返します。初期状態は \((n,k)=(0,0)\) です。同じクエリは \(O(1)\)、離れたクエリほど更新量が増えます。
入力を読んでから、必要な最大の n をコンストラクタへ渡してください。include だけでは前計算しません。comb.hpp・COMB_MAX は不要で、通常の二項係数も binom(n,k) から取得できます。
複数の状態を使う場合は、上の auto other = sum のようにコピーすると階乗・逆階乗・2の累乗の表を共有できます。query はそれぞれ独立して動き、片方の build は他方の表や状態を変更しません。IncrementalBinomialPrefixSum<> first(n), second(n); と別々に構築した場合は、それぞれ前計算します。
行と右端が同じ方向へ動く部分は斜めの漸化式でまとめ、右端だけが1動く部分は二項係数を直接加減算します。任意順のクエリにも対応し、クエリの並べ替えは行いません。
max_n を \(N\) として、構築・build は \(O(N)\) 時間・空間と逆元計算1回、max_n() は \(O(1)\) です。
query は直前の状態との差を \(\Delta n,\Delta k\) として \(O(\lvert\Delta n\rvert+\lvert\Delta k\rvert)\) 時間・\(O(1)\) 追加空間です。
クエリ数を \(Q\)、差分の総和を \(D\) とすると全体は \(O(N+Q+D)\) 時間です。表を共有するオブジェクトが \(P\) 個なら、合計空間は \(O(N+P)\) です。コピーは \(O(1)\) 時間・追加空間、binom は \(O(1)\) 時間・追加空間です。
#ifndef BINOMIAL_PREFIX_SUM_INCREMENTAL_HPP
#define BINOMIAL_PREFIX_SUM_INCREMENTAL_HPP
#include "../components/binomial_prefix_core.hpp"
#include "../components/binomial_prefix_incremental_core.hpp"
template<class Mint = mint> class IncrementalBinomialPrefixSum : public binomial_prefix_detail::IncrementalPrefixSum<Mint, binomial_prefix_detail::Table<Mint>, std::is_same_v<Mint, mint>> {
using Base = binomial_prefix_detail::IncrementalPrefixSum<Mint, binomial_prefix_detail::Table<Mint>, std::is_same_v<Mint, mint>>;
public:
explicit IncrementalBinomialPrefixSum(int max_n = 0) : Base(max_n) {}
};
#endif
#line 1 "math/binomial_prefix_sum_incremental.hpp"
#line 1 "components/binomial_prefix_core.hpp"
#line 1 "math/mint.hpp"
#include <cassert>
#include <istream>
#include <ostream>
#include <type_traits>
#if defined(__GNUC__) && !defined(__clang__) && (defined(__x86_64__) || defined(__i386__))
#pragma GCC push_options
#pragma GCC optimize("O3")
#endif
namespace mint_detail {
template <class I>
constexpr bool mint_integral = std::is_integral_v<I>
#if defined(__SIZEOF_INT128__)
|| std::is_same_v<I, __int128> || std::is_same_v<I, unsigned __int128>
#endif
;
struct [[gnu::warn_unused]] Mint {
using mint = Mint;
unsigned v = 0;
[[nodiscard]] static constexpr unsigned mod() { return 998244353; }
[[nodiscard, gnu::always_inline]] static unsigned reduce(unsigned long long x) {
return (x + (unsigned long long)(unsigned(x) * 998244351u) * mod()) >> 32;
}
[[gnu::always_inline]] Mint() = default;
template <class I, std::enable_if_t<mint_integral<I>, int> = 0>
Mint(I x) {
long long r = x % (long long)mod();
if (r < 0) r += mod();
v = reduce((unsigned long long)r * 932051910);
}
[[nodiscard, gnu::always_inline]] static Mint raw(unsigned x) {
Mint a;
a.v = reduce((unsigned long long)x * 932051910);
return a;
}
[[nodiscard, gnu::always_inline]] static Mint word(unsigned x) {
Mint a;
a.v = x;
return a;
}
[[nodiscard, gnu::always_inline]] unsigned val() const {
unsigned r = reduce(v);
return r < mod() ? r : r - mod();
}
friend std::istream &operator>>(std::istream &is, Mint &x) {
long long value;
if (is >> value) x = Mint(value);
return is;
}
friend std::ostream &operator<<(std::ostream &os, const Mint &x) {
return os << x.val();
}
[[gnu::always_inline]] Mint &operator+=(Mint b) {
v += b.v;
if (v >= 2 * mod()) v -= 2 * mod();
return *this;
}
[[gnu::always_inline]] Mint &operator-=(Mint b) {
v -= b.v;
if (v >> 31) v += 2 * mod();
return *this;
}
[[gnu::always_inline]] Mint &operator*=(Mint b) {
v = reduce((unsigned long long)v * b.v);
return *this;
}
Mint &operator/=(Mint b) { return *this *= b.inv(); }
Mint &operator++() { return *this += Mint(1); }
Mint &operator--() { return *this -= Mint(1); }
Mint operator++(int) {
Mint a = *this;
++*this;
return a;
}
Mint operator--(int) {
Mint a = *this;
--*this;
return a;
}
[[nodiscard, gnu::always_inline]] Mint operator+() const { return *this; }
[[nodiscard, gnu::always_inline]] Mint operator-() const { return word(v ? 2 * mod() - v : 0); }
[[nodiscard, gnu::always_inline]] Mint operator+(Mint b) const { return Mint(*this) += b; }
[[nodiscard, gnu::always_inline]] Mint operator-(Mint b) const { return Mint(*this) -= b; }
[[nodiscard, gnu::always_inline]] Mint operator*(Mint b) const { return Mint(*this) *= b; }
[[nodiscard]] Mint operator/(Mint b) const { return Mint(*this) /= b; }
[[nodiscard, gnu::always_inline]] bool operator==(Mint b) const { return (v < mod() ? v : v - mod()) == (b.v < mod() ? b.v : b.v - mod()); }
[[nodiscard, gnu::always_inline]] bool operator!=(Mint b) const { return !(*this == b); }
template <class I, std::enable_if_t<mint_integral<I>, int> = 0>
[[nodiscard]] friend Mint operator+(I a, Mint b) { return Mint(a) + b; }
template <class I, std::enable_if_t<mint_integral<I>, int> = 0>
[[nodiscard]] friend Mint operator-(I a, Mint b) { return Mint(a) - b; }
template <class I, std::enable_if_t<mint_integral<I>, int> = 0>
[[nodiscard]] friend Mint operator*(I a, Mint b) { return Mint(a) * b; }
template <class I, std::enable_if_t<mint_integral<I>, int> = 0>
[[nodiscard]] friend Mint operator/(I a, Mint b) { return Mint(a) / b; }
template <class I, std::enable_if_t<mint_integral<I>, int> = 0>
[[nodiscard]] friend bool operator==(I a, Mint b) { return Mint(a) == b; }
template <class I, std::enable_if_t<mint_integral<I>, int> = 0>
[[nodiscard]] friend bool operator!=(I a, Mint b) { return Mint(a) != b; }
[[nodiscard]] Mint pow(long long n) const {
assert(n >= 0);
if (!n) return Mint(1);
Mint r(1), a = *this;
for (; n > 1; n >>= 1, a *= a)
if (n & 1) r *= a;
return r * a;
}
[[nodiscard, gnu::noinline]] Mint inv() const {
assert(*this != Mint(0));
Mint a2 = *this * *this, a3 = a2 * *this;
Mint a7 = a3 * a3 * *this;
Mint a31 = a7;
for (int i = 0; i < 2; ++i) a31 *= a31;
a31 *= a3;
Mint r = a7;
for (int i = 0; i < 3; ++i) r *= r;
r *= a3;
r *= r;
for (int j = 0; j < 4; ++j) {
for (int i = 0; i < 5; ++i) r *= r;
r *= a31;
}
for (int i = 0; i < 3; ++i) r *= r;
return r * a7;
}
};
} // namespace mint_detail
using mint = mint_detail::Mint;
using fps_mint = mint;
#if defined(__GNUC__) && !defined(__clang__) && (defined(__x86_64__) || defined(__i386__))
#pragma GCC pop_options
#endif
#line 1 "components/mint_factorials.hpp"
#line 1 "components/mint_arithmetic.hpp"
#line 5 "components/mint_arithmetic.hpp"
#if defined(__x86_64__) || defined(__i386__)
#include <immintrin.h>
#endif
#if defined(__GNUC__) && !defined(__clang__) && (defined(__x86_64__) || defined(__i386__))
#pragma GCC push_options
#pragma GCC optimize("O3")
#endif
namespace mint_detail {
struct Ops {
using T = mint;
typedef unsigned int U __attribute__((may_alias));
static constexpr U mod = 998244353, twice = 2 * mod, one = 301989884;
static U reduce(unsigned long long x) { return T::reduce(x); }
static U mul(U a, U b) { return reduce((unsigned long long)a * b); }
static U add(U a, U b) {
U c = a + b;
return c < twice ? c : c - twice;
}
static U sub(U a, U b) {
U c = a - b;
return c < twice ? c : c + twice;
}
static U in(U a) { return mul(a, 932051910); }
static U out(U a) {
a = reduce(a);
return a < mod ? a : a - mod;
}
static U quotient(U r) { return ((unsigned long long)r << 32) / mod; }
static U fixed_mul(U a, U r, U q) {
return a * r - U(((unsigned long long)a * q) >> 32) * mod;
}
#if defined(__x86_64__) || defined(__i386__)
static bool vectorized() {
#if defined(__AVX2__)
return true;
#else
static const bool available = __builtin_cpu_supports("avx2");
return available;
#endif
}
using I8 = __m256i;
__attribute__((target("avx2"))) static I8 load8(const U *a) {
return _mm256_loadu_si256(reinterpret_cast<const I8 *>(a));
}
__attribute__((target("avx2"))) static void store8(U *a, I8 x) {
_mm256_storeu_si256(reinterpret_cast<I8 *>(a), x);
}
__attribute__((target("avx2"), always_inline)) static inline I8 reduce8(I8 x, I8 y) {
I8 r = _mm256_set1_epi32(998244351), p = _mm256_set1_epi32(mod);
x = _mm256_add_epi64(x, _mm256_mul_epu32(_mm256_mul_epu32(x, r), p));
y = _mm256_add_epi64(y, _mm256_mul_epu32(_mm256_mul_epu32(y, r), p));
return _mm256_blend_epi32(_mm256_srli_epi64(x, 32), y, 0xaa);
}
__attribute__((target("avx2"))) static I8 mul8(I8 a, I8 b) {
return reduce8(_mm256_mul_epu32(a, b), _mm256_mul_epu32(_mm256_srli_epi64(a, 32), _mm256_srli_epi64(b, 32)));
}
__attribute__((target("avx2"))) static I8 fixed_mul8(I8 a, I8 r, I8 q) {
I8 x = _mm256_srli_epi64(_mm256_mul_epu32(a, q), 32);
I8 y = _mm256_mul_epu32(_mm256_srli_epi64(a, 32), q);
I8 t = _mm256_blend_epi32(x, y, 0xaa);
return _mm256_sub_epi32(_mm256_mullo_epi32(a, r),
_mm256_mullo_epi32(t, _mm256_set1_epi32(mod)));
}
__attribute__((target("avx2"))) static I8 fixed_even8(I8 a, I8 r, I8 q) {
I8 t = _mm256_srli_epi64(_mm256_mul_epu32(a, q), 32);
return _mm256_sub_epi64(_mm256_mul_epu32(a, r),
_mm256_mul_epu32(t, _mm256_set1_epi32(mod)));
}
__attribute__((target("avx2"))) static I8 add8(I8 a, I8 b) {
I8 x = _mm256_add_epi32(a, b);
return _mm256_min_epu32(x, _mm256_sub_epi32(x, _mm256_set1_epi32(twice)));
}
__attribute__((target("avx2"))) static I8 sub8(I8 a, I8 b) {
I8 x = _mm256_sub_epi32(a, b);
return _mm256_min_epu32(x, _mm256_add_epi32(x, _mm256_set1_epi32(twice)));
}
#endif
};
}
#if defined(__GNUC__) && !defined(__clang__) && (defined(__x86_64__) || defined(__i386__))
#pragma GCC pop_options
#endif
#line 5 "components/mint_factorials.hpp"
namespace mint_detail {
#if defined(__x86_64__) || defined(__i386__)
__attribute__((target("avx2"))) inline void factorial_transpose(Ops::I8 (&x)[8]) {
Ops::I8 a[8], b[8];
for (int i = 0; i < 8; i += 2) {
a[i] = _mm256_unpacklo_epi32(x[i], x[i + 1]);
a[i + 1] = _mm256_unpackhi_epi32(x[i], x[i + 1]);
}
for (int i = 0; i < 8; i += 4) {
b[i] = _mm256_unpacklo_epi64(a[i], a[i + 2]);
b[i + 1] = _mm256_unpackhi_epi64(a[i], a[i + 2]);
b[i + 2] = _mm256_unpacklo_epi64(a[i + 1], a[i + 3]);
b[i + 3] = _mm256_unpackhi_epi64(a[i + 1], a[i + 3]);
}
for (int i = 0; i < 4; ++i) {
x[i] = _mm256_permute2x128_si256(b[i], b[i + 4], 0x20);
x[i + 4] = _mm256_permute2x128_si256(b[i], b[i + 4], 0x31);
}
}
template<bool reverse>
__attribute__((target("avx2"))) inline void factorial_chain(Ops::U* out, int chunk, Ops::I8 value, Ops::I8 factor) {
using I = Ops::I8;
I step = _mm256_set1_epi32(Ops::one);
I order = _mm256_setr_epi32(7, 6, 5, 4, 3, 2, 1, 0);
for (int j = 0; j < chunk; j += 8) {
I block[8];
for (int k = 0; k < 8; ++k) {
block[k] = value;
value = Ops::mul8(value, factor);
if constexpr (reverse) factor = Ops::sub8(factor, step);
else factor = Ops::add8(factor, step);
}
factorial_transpose(block);
for (int k = 0; k < 8; ++k) {
if constexpr (reverse) Ops::store8(out + (k + 1) * chunk - j - 8, _mm256_permutevar8x32_epi32(block[k], order));
else Ops::store8(out + k * chunk + j, block[k]);
}
}
}
__attribute__((target("avx2"))) inline void factorials8(Ops::U* fact, Ops::U* invfact, int n) {
using I = Ops::I8;
using U = Ops::U;
const int chunk = n / 256 * 8, covered = chunk * 32;
alignas(32) U factor[32], products[32], starts[33], inverse[33];
I p[4], x[4], step = _mm256_set1_epi32(Ops::one);
for (int i = 0; i < 32; ++i) factor[i] = Ops::in(i * chunk + 1);
for (int k = 0; k < 4; ++k) p[k] = _mm256_set1_epi32(Ops::one), x[k] = Ops::load8(factor + 8 * k);
for (int i = 0; i < chunk; ++i) {
for (int k = 0; k < 4; ++k) p[k] = Ops::mul8(p[k], x[k]), x[k] = Ops::add8(x[k], step);
}
for (int k = 0; k < 4; ++k) Ops::store8(products + 8 * k, p[k]);
starts[0] = Ops::one;
for (int i = 0; i < 32; ++i) starts[i + 1] = Ops::mul(starts[i], products[i]);
U last = starts[32];
for (int i = covered; i < n; ++i) fact[i] = last, last = Ops::mul(last, Ops::in(i + 1));
last = mint::word(last).inv().v;
for (int i = n - 1; i >= covered; --i) last = Ops::mul(last, Ops::in(i + 1)), invfact[i] = last;
inverse[32] = last;
for (int i = 31; i >= 0; --i) inverse[i] = Ops::mul(inverse[i + 1], products[i]);
for (int k = 0; k < 4; ++k) {
factorial_chain<false>(fact + 8 * k * chunk, chunk, Ops::load8(starts + 8 * k), Ops::load8(factor + 8 * k));
alignas(32) U values[8], factors[8];
for (int j = 0; j < 8; ++j) {
const int end = (8 * k + j + 1) * chunk;
values[j] = Ops::mul(inverse[8 * k + j + 1], Ops::in(end));
factors[j] = Ops::in(end - 1);
}
factorial_chain<true>(invfact + 8 * k * chunk, chunk, Ops::load8(values), Ops::load8(factors));
}
}
#endif
inline void factorials(Ops::U* fact, Ops::U* invfact, int n) {
if (!n) return;
#if defined(__x86_64__) || defined(__i386__)
if (n >= 256 && Ops::vectorized()) {
factorials8(fact, invfact, n);
return;
}
#endif
Ops::U value = Ops::one;
for (int i = 0; i < n; ++i) fact[i] = value, value = Ops::mul(value, Ops::in(i + 1));
value = mint::word(fact[n - 1]).inv().v;
for (int i = n - 1; i >= 0; --i) invfact[i] = value, value = Ops::mul(value, Ops::in(i));
}
template<class T> requires std::is_same_v<T, mint>
inline void factorials(T* fact, T* invfact, int n) {
assert(0 <= n && unsigned(n) <= mint::mod());
static_assert(sizeof(mint) == sizeof(Ops::U) && std::is_trivially_copyable_v<mint>);
if (unsigned(n) == mint::mod()) {
factorials(fact, invfact, n - 1);
fact[n - 1] = -fact[n - 2];
invfact[n - 1] = -invfact[n - 2];
return;
}
factorials(reinterpret_cast<Ops::U*>(fact), reinterpret_cast<Ops::U*>(invfact), n);
}
}
#line 7 "components/binomial_prefix_core.hpp"
#include <cstdint>
#include <limits>
#line 10 "components/binomial_prefix_core.hpp"
#include <vector>
namespace binomial_prefix_detail {
template<class Mint> struct Table {
std::vector<Mint> factorial, inverse_factorial, power2;
Mint half;
explicit Table(int n = 0) { build(n); }
void build(int n) {
assert(0 <= n && n < std::numeric_limits<int>::max() && std::uint64_t(n) < Mint::mod() && Mint::mod() > 1);
factorial.resize(n + 1), inverse_factorial.resize(n + 1), power2.resize(n + 1);
if constexpr (std::is_same_v<Mint, mint>) {
mint_detail::factorials(factorial.data(), inverse_factorial.data(), n + 1);
power2[0] = Mint(1);
for (int i = 1; i <= n; ++i) power2[i] = power2[i - 1] + power2[i - 1];
} else {
factorial[0] = power2[0] = Mint(1);
for (int i = 1; i <= n; ++i) factorial[i] = factorial[i - 1] * Mint(i), power2[i] = power2[i - 1] + power2[i - 1];
inverse_factorial[n] = factorial[n].inv();
for (int i = n; i > 0; --i) inverse_factorial[i - 1] = inverse_factorial[i] * Mint(i);
}
half = Mint((std::uint64_t(Mint::mod()) + 1) / 2);
}
Mint binom(int n, int k) const {
if (k < 0 || k > n) return Mint(0);
return factorial[n] * inverse_factorial[k] * inverse_factorial[n - k];
}
Mint center(int n) const {
if (!n) return Mint(0);
return n & 1 ? power2[n - 1] : (power2[n] - binom(n, n / 2)) * half;
}
Mint range(int n, int l, int r) const {
assert(0 <= l && l <= r && r <= n + 1);
if constexpr (std::is_same_v<Mint, mint>) {
__uint128_t sum = 0;
for (int i = l; i < r; ++i) sum += std::uint64_t(inverse_factorial[i].v) * inverse_factorial[n - i].v;
return factorial[n] * Mint::word(Mint::reduce(std::uint64_t(sum % Mint::mod())));
} else {
Mint sum(0);
for (int i = l; i < r; ++i) sum += inverse_factorial[i] * inverse_factorial[n - i];
return factorial[n] * sum;
}
}
};
}
#line 1 "components/binomial_prefix_incremental_core.hpp"
#include <algorithm>
#line 7 "components/binomial_prefix_incremental_core.hpp"
#include <memory>
namespace binomial_prefix_detail {
template<class Mint, class Table, bool FastHalf> class IncrementalPrefixSum {
std::shared_ptr<const Table> table_;
int n_ = 0, k_ = 0;
Mint value_ = Mint(0);
Mint halve(Mint value) const {
if constexpr (FastHalf) return Mint::word((value.v + (value.v & 1) * Mint::mod()) >> 1);
else return value * table_->half;
}
public:
explicit IncrementalPrefixSum(int max_n = 0) : table_(std::make_shared<Table>(max_n)) {}
void build(int max_n) {
table_ = std::make_shared<Table>(max_n);
n_ = k_ = 0;
value_ = Mint(0);
}
int max_n() const { return int(table_->factorial.size()) - 1; }
Mint binom(int n, int k) const {
if (n < 0 || k < 0 || k > n) return Mint(0);
assert(n <= max_n());
return table_->binom(n, k);
}
[[gnu::always_inline]] Mint query(int n, std::int64_t k) {
assert(0 <= n && n <= max_n());
int m = int(std::clamp(k, std::int64_t(0), std::int64_t(n) + 1));
if (m <= 1 || m == n + 1) {
n_ = n, k_ = m;
return value_ = m == 0 ? Mint(0) : m == 1 ? Mint(1) : table_->power2[n];
}
const Table& table = *table_;
int row = n_, column = k_;
Mint value = value_;
if (column == m) {
while (row < n) value = value + value - table.binom(row++, column - 1);
while (row > n) value = halve(value + table.binom(--row, column - 1));
} else {
if (!column) row = n;
while (row < n && column < m) value = value + value + table.binom(row++, column++);
while (row > n && column > m) value = halve(value - table.binom(--row, --column));
while (row < n) value = value + value - table.binom(row++, column - 1);
if (column < m) value += column + 1 == m ? table.binom(row, column) : table.range(row, column, m);
else if (column > m) value -= m + 1 == column ? table.binom(row, m) : table.range(row, m, column);
while (row > n) value = halve(value + table.binom(--row, m - 1));
}
n_ = n, k_ = m;
return value_ = value;
}
};
}
#line 6 "math/binomial_prefix_sum_incremental.hpp"
template<class Mint = mint> class IncrementalBinomialPrefixSum : public binomial_prefix_detail::IncrementalPrefixSum<Mint, binomial_prefix_detail::Table<Mint>, std::is_same_v<Mint, mint>> {
using Base = binomial_prefix_detail::IncrementalPrefixSum<Mint, binomial_prefix_detail::Table<Mint>, std::is_same_v<Mint, mint>>;
public:
explicit IncrementalBinomialPrefixSum(int max_n = 0) : Base(max_n) {}
};