関数の合成( $\mathrm{O}(N \log^2 N)$ )
(fps/fps-composition.hpp)
Depends on
Verified with
Code
#pragma once
#include <cassert>
#include <vector>
using namespace std;
#include "formal-power-series.hpp"
// g(f(x)) を計算
template <typename mint>
FormalPowerSeries<mint> composition(FormalPowerSeries<mint> f,
FormalPowerSeries<mint> g, int deg = -1) {
using fps = FormalPowerSeries<mint>;
auto dfs = [&](auto rc, fps Q, int n, int h, int k) -> fps {
if (n == 0) {
fps T{begin(Q), begin(Q) + k};
T.push_back(1);
fps u = g * T.rev().inv().rev();
fps P(h * k);
for (int i = 0; i < (int)g.size(); i++) P[k - 1 - i] = u[i + k];
return P;
}
fps nQ(4 * h * k), nR(2 * h * k);
for (int i = 0; i < k; i++) {
copy(begin(Q) + i * h, begin(Q) + i * h + n + 1, begin(nQ) + i * 2 * h);
}
nQ[k * 2 * h] += 1;
nQ.ntt();
for (int i = 0; i < 4 * h * k; i += 2) swap(nQ[i], nQ[i + 1]);
for (int i = 0; i < 2 * h * k; i++) nR[i] = nQ[i * 2] * nQ[i * 2 + 1];
nR.intt();
nR[0] -= 1;
Q.assign(h * k, 0);
for (int i = 0; i < 2 * k; i++) {
for (int j = 0; j <= n / 2; j++) {
Q[i * h / 2 + j] = nR[i * h + j];
}
}
auto P = rc(rc, Q, n / 2, h / 2, k * 2);
fps nP(4 * h * k);
for (int i = 0; i < 2 * k; i++) {
for (int j = 0; j <= n / 2; j++) {
nP[i * 2 * h + j * 2 + n % 2] = P[i * h / 2 + j];
}
}
nP.ntt();
for (int i = 1; i < 4 * h * k; i *= 2) {
reverse(begin(nQ) + i, begin(nQ) + i * 2);
}
for (int i = 0; i < 4 * h * k; i++) nP[i] *= nQ[i];
nP.intt();
P.assign(h * k, 0);
for (int i = 0; i < k; i++) {
copy(begin(nP) + i * 2 * h, begin(nP) + i * 2 * h + n + 1,
begin(P) + i * h);
}
return P;
};
if (deg == -1) deg = max(f.size(), g.size());
f.resize(deg), g.resize(deg);
int n = f.size() - 1, k = 1;
int h = 1;
while (h < n + 1) h *= 2;
fps Q(h * k);
for (int i = 0; i <= n; i++) Q[i] = -f[i];
fps P = dfs(dfs, Q, n, h, k);
return P.pre(n + 1).rev();
}
/**
* @brief 関数の合成( $\mathrm{O}(N \log^2 N)$ )
*/
#line 2 "fps/fps-composition.hpp"
#include <cassert>
#include <vector>
using namespace std;
#line 2 "fps/formal-power-series.hpp"
template <typename mint>
struct FormalPowerSeries : vector<mint> {
using vector<mint>::vector;
using FPS = FormalPowerSeries;
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.back().inverse();
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;
}
// 前 sz 項を取ってくる。sz に足りない項は 0 埋めする
FPS pre(int sz) const {
FPS ret(begin(*this), begin(*this) + min((int)this->size(), sz));
if ((int)ret.size() < sz) ret.resize(sz);
return ret;
}
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) 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).empty() && (*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_fft();
FPS &operator*=(const FPS &r);
void ntt();
void intt();
void ntt_doubling();
static int ntt_pr();
FPS inv(int deg = -1) const;
FPS exp(int deg = -1) const;
};
template <typename mint>
void *FormalPowerSeries<mint>::ntt_ptr = nullptr;
/**
* @brief 多項式/形式的冪級数ライブラリ
* @docs docs/fps/formal-power-series.md
*/
#line 8 "fps/fps-composition.hpp"
// g(f(x)) を計算
template <typename mint>
FormalPowerSeries<mint> composition(FormalPowerSeries<mint> f,
FormalPowerSeries<mint> g, int deg = -1) {
using fps = FormalPowerSeries<mint>;
auto dfs = [&](auto rc, fps Q, int n, int h, int k) -> fps {
if (n == 0) {
fps T{begin(Q), begin(Q) + k};
T.push_back(1);
fps u = g * T.rev().inv().rev();
fps P(h * k);
for (int i = 0; i < (int)g.size(); i++) P[k - 1 - i] = u[i + k];
return P;
}
fps nQ(4 * h * k), nR(2 * h * k);
for (int i = 0; i < k; i++) {
copy(begin(Q) + i * h, begin(Q) + i * h + n + 1, begin(nQ) + i * 2 * h);
}
nQ[k * 2 * h] += 1;
nQ.ntt();
for (int i = 0; i < 4 * h * k; i += 2) swap(nQ[i], nQ[i + 1]);
for (int i = 0; i < 2 * h * k; i++) nR[i] = nQ[i * 2] * nQ[i * 2 + 1];
nR.intt();
nR[0] -= 1;
Q.assign(h * k, 0);
for (int i = 0; i < 2 * k; i++) {
for (int j = 0; j <= n / 2; j++) {
Q[i * h / 2 + j] = nR[i * h + j];
}
}
auto P = rc(rc, Q, n / 2, h / 2, k * 2);
fps nP(4 * h * k);
for (int i = 0; i < 2 * k; i++) {
for (int j = 0; j <= n / 2; j++) {
nP[i * 2 * h + j * 2 + n % 2] = P[i * h / 2 + j];
}
}
nP.ntt();
for (int i = 1; i < 4 * h * k; i *= 2) {
reverse(begin(nQ) + i, begin(nQ) + i * 2);
}
for (int i = 0; i < 4 * h * k; i++) nP[i] *= nQ[i];
nP.intt();
P.assign(h * k, 0);
for (int i = 0; i < k; i++) {
copy(begin(nP) + i * 2 * h, begin(nP) + i * 2 * h + n + 1,
begin(P) + i * h);
}
return P;
};
if (deg == -1) deg = max(f.size(), g.size());
f.resize(deg), g.resize(deg);
int n = f.size() - 1, k = 1;
int h = 1;
while (h < n + 1) h *= 2;
fps Q(h * k);
for (int i = 0; i <= n; i++) Q[i] = -f[i];
fps P = dfs(dfs, Q, n, h, k);
return P.pre(n + 1).rev();
}
/**
* @brief 関数の合成( $\mathrm{O}(N \log^2 N)$ )
*/
Back to top page