有理式の和
(fps/sum-of-rationals.hpp)
Depends on
Code
#pragma once
#include "fps/formal-power-series.hpp"
#include "fps/fps-rational.hpp"
template <class mint>
FPSRational<mint> SumOfRationals(vector<FPSRational<mint>> rs) {
if (ps.empty()) return {};
for (auto& r : rs) {
r.num.shrink(), r.den.shrink();
if (r.den.size() < r.num.size()) r.num.resize(r.den.size());
}
const int B = 1 << 5;
for (int i = 0, j = -1; i < rs.size(); i++) {
if (rs[i].den.size() > B) continue;
if (j == -1 || rs[i].den.size() + rs[j].den.size() - 1 > B) {
j = i;
continue;
}
rs[j] += rs[i];
swap(rs[i--], rs.back());
rs.pop_back();
}
if (rs.size() == 1) return rs[0];
for (auto& r : rs) {
int sz = B;
while (sz < r.size()) sz <<= 1;
r.num.resize(sz);
r.num.ntt();
r.den.resize(sz);
r.den.ntt();
}
for (int sz = B * 2; rs.size() > 1; sz <<= 1) {
for (int i = 0, j = -1; i < rs.size(); i++) {
if (rs[i].den.size() >= sz) continue;
rs[i].num.ntt_doubling();
rs[i].den.ntt_doubling();
if (j == -1) {
j = i;
} else {
for (int k = 0; k < sz; k++) rs[j].num[k] = rs[j].num[k] * rs[i].den[k] + rs[j].den[k] * rs[i].num[k];
for (int k = 0; k < sz; k++) rs[j].den[k] *= rs[i].den[k];
swap(rs[i--], rs.back());
rs.pop_back();
j = -1;
}
}
}
rs[0].num.intt();
rs[0].num.shrink();
rs[0].den.intt();
rs[0].den.shrink();
return rs[0];
}
/**
* @brief 有理式の和
*/
#line 2 "fps/formal-power-series.hpp"
template <class 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.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) return {};
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 3 "fps/fps-rational.hpp"
template <class mint>
struct FPSRational {
using F = FormalPowerSeries<mint>;
using R = FPSRational;
F num, den;
R& operator+=(const R& r) {
num *= r.den;
num += den * r.num;
den *= r.den;
return *this;
}
R& operator-=(const R& r) {
num *= r.den;
num -= den * r.num;
den *= r.den;
return *this;
}
R& operator*=(const R& r) {
num *= r.num;
den *= r.den;
return *this;
}
R& operator/=(const R& r) {
num *= r.den;
den *= r.num;
return *this;
}
R operator+(const R& r) const { return R(*this) += r; }
R operator-(const R& r) const { return R(*this) -= r; }
R operator*(const R& r) const { return R(*this) *= r; }
R operator/(const R& r) const { return R(*this) /= r; }
R inv() const { return {den, num}; }
F approx(int deg) const { return (den * num.inv(deg)).pre(deg); }
};
#line 4 "fps/sum-of-rationals.hpp"
template <class mint>
FPSRational<mint> SumOfRationals(vector<FPSRational<mint>> rs) {
if (ps.empty()) return {};
for (auto& r : rs) {
r.num.shrink(), r.den.shrink();
if (r.den.size() < r.num.size()) r.num.resize(r.den.size());
}
const int B = 1 << 5;
for (int i = 0, j = -1; i < rs.size(); i++) {
if (rs[i].den.size() > B) continue;
if (j == -1 || rs[i].den.size() + rs[j].den.size() - 1 > B) {
j = i;
continue;
}
rs[j] += rs[i];
swap(rs[i--], rs.back());
rs.pop_back();
}
if (rs.size() == 1) return rs[0];
for (auto& r : rs) {
int sz = B;
while (sz < r.size()) sz <<= 1;
r.num.resize(sz);
r.num.ntt();
r.den.resize(sz);
r.den.ntt();
}
for (int sz = B * 2; rs.size() > 1; sz <<= 1) {
for (int i = 0, j = -1; i < rs.size(); i++) {
if (rs[i].den.size() >= sz) continue;
rs[i].num.ntt_doubling();
rs[i].den.ntt_doubling();
if (j == -1) {
j = i;
} else {
for (int k = 0; k < sz; k++) rs[j].num[k] = rs[j].num[k] * rs[i].den[k] + rs[j].den[k] * rs[i].num[k];
for (int k = 0; k < sz; k++) rs[j].den[k] *= rs[i].den[k];
swap(rs[i--], rs.back());
rs.pop_back();
j = -1;
}
}
}
rs[0].num.intt();
rs[0].num.shrink();
rs[0].den.intt();
rs[0].den.shrink();
return rs[0];
}
/**
* @brief 有理式の和
*/
Back to top page
fps/formal-power-series.hpp