library
This documentation is automatically generated by online-judge-tools/verification-helper
graph/count/BEST.hpp
- View this file on GitHub
- Last update: 2026-05-09 07:11:35+09:00
- Include:
#include "graph/count/BEST.hpp"
Depends on
- ds/hashmap.hpp
- graph/base.hpp
- linalg/blackbox/det.hpp
- linalg/blackbox/min_poly.hpp
- linalg/det.hpp
- mod/barrett.hpp
- mod/crt3.hpp
- mod/mod_inv.hpp
- mod/modint.hpp
- mod/modint_common.hpp
- poly/convolution.hpp
- poly/convolution_karatsuba.hpp
- poly/convolution_naive.hpp
- poly/count_terms.hpp
- poly/fps_inv.hpp
- poly/ntt.hpp
- poly/poly_divmod.hpp
- poly/poly_gcd.hpp
- random/base.hpp
- seq/find_linear_rec.hpp
Verified with
- test/2_library_checker/graph/counting_eulerian_dense.test.cpp
- test/2_library_checker/graph/counting_eulerian_sparse.test.cpp
Code
#include "graph/base.hpp"
#include "linalg/blackbox/det.hpp"
#include "linalg/det.hpp"
/*
ひとつ選んだ辺から始めて全ての辺を通る closed walk を数える.
多重辺は vc<int>(eid) で渡す，なければすべて 1. e.cost は参照しない.
辺はラベル付きで考える. 多重辺を同一視する場合などは後で階乗で割ること.
O(N^2+NM) （ + 最後に重複度の階乗をかける）．
*/
template <typename mint, bool sparse, typename GT>
mint BEST_theorem(GT G, vc<int> edge_multiplicity = {}) {
static_assert(GT::is_directed);
int N = G.N, M = G.M;
if (M == 0) return 0;
if (edge_multiplicity.empty()) edge_multiplicity.assign(M, 1);
vc<int> vs;
for (auto& e: G.edges) {
if (edge_multiplicity[e.id] == 0) continue;
vs.eb(e.frm), vs.eb(e.to);
}
UNIQUE(vs);
G = G.rearrange(vs, true);
N = G.N;
vc<int> indeg(N), outdeg(N);
if constexpr (sparse) {
vc<tuple<int, int, mint>> mat;
for (auto& e: G.edges) {
int a = e.frm, b = e.to, x = edge_multiplicity[e.id];
outdeg[a] += x, indeg[b] += x;
if (a < N - 1 && b < N - 1) mat.eb(a, b, -x);
if (a < N - 1) mat.eb(a, a, x);
}
FOR(v, N) if (indeg[v] != outdeg[v]) return 0;
auto apply = [&](vc<mint> A) -> vc<mint> {
vc<mint> B(N - 1);
for (auto& [a, b, c]: mat) B[b] += A[a] * c;
return B;
};
mint d = blackbox_det<mint>(N - 1, apply);
for (auto& x: outdeg) { d *= fact<mint>(x - 1); }
return d;
} else {
// dense
vv(mint, mat, N - 1, N - 1);
for (auto& e: G.edges) {
int a = e.frm, b = e.to, x = edge_multiplicity[e.id];
outdeg[a] += x, indeg[b] += x;
if (a < N - 1 && b < N - 1) mat[a][b] -= x;
if (a < N - 1) mat[a][a] += x;
}
FOR(v, N) if (indeg[v] != outdeg[v]) return 0;
mint d = det(mat);
for (auto& x: outdeg) { d *= fact<mint>(x - 1); }
return d;
}
}#line 2 "ds/hashmap.hpp"
// u64 -> Val
template <typename Val>
struct HashMap {
// n は入れたいものの個数で ok
HashMap(u32 n = 0) { build(n); }
void build(u32 n) {
u32 k = 8;
while (k < n * 2) k *= 2;
cap = k / 2, mask = k - 1;
key.resize(k), val.resize(k), used.assign(k, 0);
}
// size を保ったまま. size=0 にするときは build すること.
void clear() {
used.assign(len(used), 0);
cap = (mask + 1) / 2;
}
int size() { return len(used) / 2 - cap; }
int index(const u64& k) {
int i = 0;
for (i = hash(k); used[i] && key[i] != k; i = (i + 1) & mask) {}
return i;
}
Val& operator[](const u64& k) {
if (cap == 0) extend();
int i = index(k);
if (!used[i]) { used[i] = 1, key[i] = k, val[i] = Val{}, --cap; }
return val[i];
}
Val get(const u64& k, Val default_value) {
int i = index(k);
return (used[i] ? val[i] : default_value);
}
bool count(const u64& k) {
int i = index(k);
return used[i] && key[i] == k;
}
// f(key, val)
template <typename F>
void enumerate_all(F f) {
FOR(i, len(used)) if (used[i]) f(key[i], val[i]);
}
private:
u32 cap, mask;
vc<u64> key;
vc<Val> val;
vc<bool> used;
u64 hash(u64 x) {
static const u64 FIXED_RANDOM = std::chrono::steady_clock::now().time_since_epoch().count();
x += FIXED_RANDOM;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return (x ^ (x >> 31)) & mask;
}
void extend() {
vc<pair<u64, Val>> dat;
dat.reserve(len(used) / 2 - cap);
FOR(i, len(used)) {
if (used[i]) dat.eb(key[i], val[i]);
}
build(2 * len(dat));
for (auto& [a, b]: dat) (*this)[a] = b;
}
};
#line 3 "graph/base.hpp"
template <typename T>
struct Edge {
int frm, to;
T cost;
int id;
};
template <typename T = int, bool directed = false>
struct Graph {
static constexpr bool is_directed = directed;
int N, M;
using cost_type = T;
using edge_type = Edge<T>;
vector<edge_type> edges;
vector<int> indptr;
vector<edge_type> csr_edges;
vc<int> vc_deg, vc_indeg, vc_outdeg;
bool prepared;
class OutgoingEdges {
public:
OutgoingEdges(const Graph* G, int l, int r) : G(G), l(l), r(r) {}
const edge_type* begin() const {
if (l == r) { return 0; }
return &G->csr_edges[l];
}
const edge_type* end() const {
if (l == r) { return 0; }
return &G->csr_edges[r];
}
private:
const Graph* G;
int l, r;
};
bool is_prepared() { return prepared; }
Graph() : N(0), M(0), prepared(0) {}
Graph(int N) : N(N), M(0), prepared(0) {}
void build(int n) {
N = n, M = 0;
prepared = 0;
edges.clear();
indptr.clear();
csr_edges.clear();
vc_deg.clear();
vc_indeg.clear();
vc_outdeg.clear();
}
void add(int frm, int to, T cost = 1, int i = -1) {
assert(!prepared);
assert(0 <= frm && 0 <= to && to < N);
if (i == -1) i = M;
auto e = edge_type({frm, to, cost, i});
edges.eb(e);
++M;
}
#ifdef FASTIO
// wt, off
void read_tree(bool wt = false, int off = 1) { read_graph(N - 1, wt, off); }
void read_graph(int M, bool wt = false, int off = 1) {
for (int m = 0; m < M; ++m) {
INT(a, b);
a -= off, b -= off;
if (!wt) {
add(a, b);
} else {
T c;
read(c);
add(a, b, c);
}
}
build();
}
#endif
void build() {
assert(!prepared);
prepared = true;
indptr.assign(N + 1, 0);
for (auto&& e: edges) {
indptr[e.frm + 1]++;
if (!directed) indptr[e.to + 1]++;
}
for (int v = 0; v < N; ++v) { indptr[v + 1] += indptr[v]; }
auto counter = indptr;
csr_edges.resize(indptr.back() + 1);
for (auto&& e: edges) {
csr_edges[counter[e.frm]++] = e;
if (!directed) csr_edges[counter[e.to]++] = edge_type({e.to, e.frm, e.cost, e.id});
}
}
OutgoingEdges operator[](int v) const {
assert(prepared);
return {this, indptr[v], indptr[v + 1]};
}
vc<int> deg_array() {
if (vc_deg.empty()) calc_deg();
return vc_deg;
}
pair<vc<int>, vc<int>> deg_array_inout() {
if (vc_indeg.empty()) calc_deg_inout();
return {vc_indeg, vc_outdeg};
}
int deg(int v) {
if (vc_deg.empty()) calc_deg();
return vc_deg[v];
}
int in_deg(int v) {
if (vc_indeg.empty()) calc_deg_inout();
return vc_indeg[v];
}
int out_deg(int v) {
if (vc_outdeg.empty()) calc_deg_inout();
return vc_outdeg[v];
}
#ifdef FASTIO
void debug() {
#ifdef LOCAL
print("Graph");
if (!prepared) {
print("frm to cost id");
for (auto&& e: edges) print(e.frm, e.to, e.cost, e.id);
} else {
print("indptr", indptr);
print("frm to cost id");
FOR(v, N) for (auto&& e: (*this)[v]) print(e.frm, e.to, e.cost, e.id);
}
#endif
}
#endif
vc<int> new_idx;
vc<bool> used_e;
// G における頂点 V[i] が、新しいグラフで i になるようにする
// {G, es}
// sum(deg(v)) の計算量になっていて、
// 新しいグラフの n+m より大きい可能性があるので注意
Graph<T, directed> rearrange(vc<int> V, bool keep_eid = 0) {
if (len(new_idx) != N) new_idx.assign(N, -1);
int n = len(V);
FOR(i, n) new_idx[V[i]] = i;
Graph<T, directed> G(n);
vc<int> history;
FOR(i, n) {
for (auto&& e: (*this)[V[i]]) {
if (len(used_e) <= e.id) used_e.resize(e.id + 1);
if (used_e[e.id]) continue;
int a = e.frm, b = e.to;
if (new_idx[a] != -1 && new_idx[b] != -1) {
history.eb(e.id);
used_e[e.id] = 1;
int eid = (keep_eid ? e.id : -1);
G.add(new_idx[a], new_idx[b], e.cost, eid);
}
}
}
FOR(i, n) new_idx[V[i]] = -1;
for (auto&& eid: history) used_e[eid] = 0;
G.build();
return G;
}
Graph<T, true> to_directed_tree(int root = -1) {
if (root == -1) root = 0;
assert(!is_directed && prepared && M == N - 1);
Graph<T, true> G1(N);
vc<int> par(N, -1);
auto dfs = [&](auto& dfs, int v) -> void {
for (auto& e: (*this)[v]) {
if (e.to == par[v]) continue;
par[e.to] = v, dfs(dfs, e.to);
}
};
dfs(dfs, root);
for (auto& e: edges) {
int a = e.frm, b = e.to;
if (par[a] == b) swap(a, b);
assert(par[b] == a);
G1.add(a, b, e.cost);
}
G1.build();
return G1;
}
HashMap<int> MP_FOR_EID;
int get_eid(u64 a, u64 b) {
if (len(MP_FOR_EID) == 0) {
MP_FOR_EID.build(N - 1);
for (auto& e: edges) {
u64 a = e.frm, b = e.to;
u64 k = to_eid_key(a, b);
MP_FOR_EID[k] = e.id;
}
}
return MP_FOR_EID.get(to_eid_key(a, b), -1);
}
u64 to_eid_key(u64 a, u64 b) {
if (!directed && a > b) swap(a, b);
return N * a + b;
}
private:
void calc_deg() {
assert(vc_deg.empty());
vc_deg.resize(N);
for (auto&& e: edges) vc_deg[e.frm]++, vc_deg[e.to]++;
}
void calc_deg_inout() {
assert(vc_indeg.empty());
vc_indeg.resize(N);
vc_outdeg.resize(N);
for (auto&& e: edges) { vc_indeg[e.to]++, vc_outdeg[e.frm]++; }
}
};
#line 2 "seq/find_linear_rec.hpp"
#line 2 "poly/poly_divmod.hpp"
#line 2 "poly/count_terms.hpp"
template<typename mint>
int count_terms(const vc<mint>& f){
int t = 0;
FOR(i, len(f)) if(f[i] != mint(0)) ++t;
return t;
}
#line 2 "poly/convolution.hpp"
#line 2 "mod/modint_common.hpp"
struct has_mod_impl {
template <class T>
static auto check(T &&x) -> decltype(x.get_mod(), std::true_type{});
template <class T>
static auto check(...) -> std::false_type;
};
template <class T>
class has_mod : public decltype(has_mod_impl::check<T>(std::declval<T>())) {};
template <typename mint>
mint fact(int n) {
static const int mod = mint::get_mod();
assert(0 <= n && n < mod);
static vector<mint> dat = {1, 1};
if (len(dat) <= n) {
int now = len(dat);
int m = min(mod, 1 << (topbit(n) + 1));
dat.resize(m);
FOR(i, now, m) dat[i] = dat[i - 1] * mint::raw(i);
}
return dat[n];
}
template <typename mint>
mint fact_inv(int n) {
static const int mod = mint::get_mod();
static vector<mint> dat = {1, 1};
if (n < 0) return mint(0);
if (len(dat) <= n) {
int now = len(dat);
int m = min(mod, 1 << (topbit(n) + 1));
dat.resize(m);
dat[m - 1] = fact<mint>(m - 1).inverse();
FOR_R(i, now, m - 1) dat[i] = dat[i + 1] * mint::raw(i + 1);
}
return dat[n];
}
template <class mint, class... Ts>
mint fact_invs(Ts... xs) {
return (mint(1) * ... * fact_inv<mint>(xs));
}
template <typename mint>
mint inv(int n) {
static const int mod = mint::get_mod();
assert(1 <= n && n < mod);
return fact<mint>(n - 1) * fact_inv<mint>(n);
}
template <>
double inv<double>(int n) {
assert(n != 0);
return 1.0 / n;
}
template <typename mint, class Head, class... Tail>
mint multinomial(Head &&head, Tail &&...tail) {
return fact<mint>(head) * fact_invs<mint>(std::forward<Tail>(tail)...);
}
template <typename mint>
mint C_dense(int n, int k) {
assert(n >= 0);
if (k < 0 || n < k) return 0;
static vvc<mint> C;
static int H = 0, W = 0;
auto calc = [&](int i, int j) -> mint {
if (i == 0) return (j == 0 ? mint(1) : mint(0));
return C[i - 1][j] + (j ? C[i - 1][j - 1] : 0);
};
if (W <= k) {
FOR(i, H) {
C[i].resize(k + 1);
FOR(j, W, k + 1) { C[i][j] = calc(i, j); }
}
W = k + 1;
}
if (H <= n) {
C.resize(n + 1);
FOR(i, H, n + 1) {
C[i].resize(W);
FOR(j, W) { C[i][j] = calc(i, j); }
}
H = n + 1;
}
return C[n][k];
}
template <typename mint, bool large = false, bool dense = false>
mint C(ll n, ll k) {
assert(n >= 0);
if (k < 0 || n < k) return 0;
if constexpr (dense) return C_dense<mint>(n, k);
if constexpr (!large) return multinomial<mint>(n, k, n - k);
k = min(k, n - k);
mint x(1);
FOR(i, k) x *= mint(n - i);
return x * fact_inv<mint>(k);
}
template <typename mint, bool large = false>
mint C_inv(ll n, ll k) {
assert(n >= 0);
assert(0 <= k && k <= n);
if (!large) return fact_inv<mint>(n) * fact<mint>(k) * fact<mint>(n - k);
return mint(1) / C<mint, 1>(n, k);
}
// [x^d](1-x)^{-n}
template <typename mint, bool large = false, bool dense = false>
mint C_negative(ll n, ll d) {
assert(n >= 0);
if (d < 0) return mint(0);
if (n == 0) {
return (d == 0 ? mint(1) : mint(0));
}
return C<mint, large, dense>(n + d - 1, d);
}
#line 3 "mod/modint.hpp"
template <int mod>
struct modint {
static constexpr u32 umod = u32(mod);
static_assert(umod < u32(1) << 31);
u32 val;
static modint raw(u32 v) {
modint x;
x.val = v;
return x;
}
constexpr modint() : val(0) {}
constexpr modint(u32 x) : val(x % umod) {}
constexpr modint(u64 x) : val(x % umod) {}
constexpr modint(u128 x) : val(x % umod) {}
constexpr modint(int x) : val((x %= mod) < 0 ? x + mod : x){};
constexpr modint(ll x) : val((x %= mod) < 0 ? x + mod : x){};
constexpr modint(i128 x) : val((x %= mod) < 0 ? x + mod : x){};
bool operator<(const modint &other) const { return val < other.val; }
modint &operator+=(const modint &p) {
if ((val += p.val) >= umod) val -= umod;
return *this;
}
modint &operator-=(const modint &p) {
if ((val += umod - p.val) >= umod) val -= umod;
return *this;
}
modint &operator*=(const modint &p) {
val = u64(val) * p.val % umod;
return *this;
}
modint &operator/=(const modint &p) {
*this *= p.inverse();
return *this;
}
modint operator-() const { return modint::raw(val ? mod - val : u32(0)); }
modint operator+(const modint &p) const { return modint(*this) += p; }
modint operator-(const modint &p) const { return modint(*this) -= p; }
modint operator*(const modint &p) const { return modint(*this) *= p; }
modint operator/(const modint &p) const { return modint(*this) /= p; }
bool operator==(const modint &p) const { return val == p.val; }
bool operator!=(const modint &p) const { return val != p.val; }
modint inverse() const {
int a = val, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b), swap(u -= t * v, v);
}
return modint(u);
}
modint pow(ll n) const {
if (n < 0) return inverse().pow(-n);
assert(n >= 0);
modint ret(1), mul(val);
while (n > 0) {
if (n & 1) ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
static constexpr int get_mod() { return mod; }
// (n, r), r は 1 の 2^n 乗根
static constexpr pair<int, int> ntt_info() {
if (mod == 120586241) return {20, 74066978};
if (mod == 167772161) return {25, 17};
if (mod == 469762049) return {26, 30};
if (mod == 754974721) return {24, 362};
if (mod == 880803841) return {23, 211};
if (mod == 943718401) return {22, 663003469};
if (mod == 998244353) return {23, 31};
if (mod == 1004535809) return {21, 582313106};
if (mod == 1012924417) return {21, 368093570};
if (mod == 1224736769) return {24, 1191450770};
if (mod == 2013265921) return {27, 244035102};
return {-1, -1};
}
static constexpr bool can_ntt() { return ntt_info().fi != -1; }
};
#ifdef FASTIO
template <int mod>
void rd(modint<mod> &x) {
fastio::rd(x.val);
x.val %= mod;
// assert(0 <= x.val && x.val < mod);
}
template <int mod>
void wt(modint<mod> x) {
fastio::wt(x.val);
}
#endif
using modint107 = modint<1000000007>;
using modint998 = modint<998244353>;
#line 2 "mod/mod_inv.hpp"
// long でも大丈夫
// (val * x - 1) が mod の倍数になるようにする
// 特に mod=0 なら x=0 が満たす
ll mod_inv(ll val, ll mod) {
if (mod == 0) return 0;
mod = abs(mod);
val %= mod;
if (val < 0) val += mod;
ll a = val, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b), swap(u -= t * v, v);
}
if (u < 0) u += mod;
return u;
}
#line 2 "mod/crt3.hpp"
constexpr u32 mod_pow_constexpr(u64 a, u64 n, u32 mod) {
a %= mod;
u64 res = 1;
FOR(32) {
if (n & 1) res = res * a % mod;
a = a * a % mod, n /= 2;
}
return res;
}
template <typename T, u32 p0, u32 p1>
T CRT2(u64 a0, u64 a1) {
static_assert(p0 < p1);
static constexpr u64 x0_1 = mod_pow_constexpr(p0, p1 - 2, p1);
u64 c = (a1 - a0 + p1) * x0_1 % p1;
return a0 + c * p0;
}
template <typename T, u32 p0, u32 p1, u32 p2>
T CRT3(u64 a0, u64 a1, u64 a2) {
static_assert(p0 < p1 && p1 < p2);
static constexpr u64 x1 = mod_pow_constexpr(p0, p1 - 2, p1);
static constexpr u64 x2 = mod_pow_constexpr(u64(p0) * p1 % p2, p2 - 2, p2);
static constexpr u64 p01 = u64(p0) * p1;
u64 c = (a1 - a0 + p1) * x1 % p1;
u64 ans_1 = a0 + c * p0;
c = (a2 - ans_1 % p2 + p2) * x2 % p2;
return T(ans_1) + T(c) * T(p01);
}
template <typename T, u32 p0, u32 p1, u32 p2, u32 p3>
T CRT4(u64 a0, u64 a1, u64 a2, u64 a3) {
static_assert(p0 < p1 && p1 < p2 && p2 < p3);
static constexpr u64 x1 = mod_pow_constexpr(p0, p1 - 2, p1);
static constexpr u64 x2 = mod_pow_constexpr(u64(p0) * p1 % p2, p2 - 2, p2);
static constexpr u64 x3 = mod_pow_constexpr(u64(p0) * p1 % p3 * p2 % p3, p3 - 2, p3);
static constexpr u64 p01 = u64(p0) * p1;
u64 c = (a1 - a0 + p1) * x1 % p1;
u64 ans_1 = a0 + c * p0;
c = (a2 - ans_1 % p2 + p2) * x2 % p2;
u128 ans_2 = ans_1 + c * static_cast<u128>(p01);
c = (a3 - ans_2 % p3 + p3) * x3 % p3;
return T(ans_2) + T(c) * T(p01) * T(p2);
}
template <typename T, u32 p0, u32 p1, u32 p2, u32 p3, u32 p4>
T CRT5(u64 a0, u64 a1, u64 a2, u64 a3, u64 a4) {
static_assert(p0 < p1 && p1 < p2 && p2 < p3 && p3 < p4);
static constexpr u64 x1 = mod_pow_constexpr(p0, p1 - 2, p1);
static constexpr u64 x2 = mod_pow_constexpr(u64(p0) * p1 % p2, p2 - 2, p2);
static constexpr u64 x3 = mod_pow_constexpr(u64(p0) * p1 % p3 * p2 % p3, p3 - 2, p3);
static constexpr u64 x4 = mod_pow_constexpr(u64(p0) * p1 % p4 * p2 % p4 * p3 % p4, p4 - 2, p4);
static constexpr u64 p01 = u64(p0) * p1;
static constexpr u64 p23 = u64(p2) * p3;
u64 c = (a1 - a0 + p1) * x1 % p1;
u64 ans_1 = a0 + c * p0;
c = (a2 - ans_1 % p2 + p2) * x2 % p2;
u128 ans_2 = ans_1 + c * static_cast<u128>(p01);
c = static_cast<u64>(a3 - ans_2 % p3 + p3) * x3 % p3;
u128 ans_3 = ans_2 + static_cast<u128>(c * p2) * p01;
c = static_cast<u64>(a4 - ans_3 % p4 + p4) * x4 % p4;
return T(ans_3) + T(c) * T(p01) * T(p23);
}
#line 2 "poly/convolution_naive.hpp"
template <class T, typename enable_if<!has_mod<T>::value>::type* = nullptr>
vc<T> convolution_naive(const vc<T>& a, const vc<T>& b) {
int n = int(a.size()), m = int(b.size());
if (n > m) return convolution_naive<T>(b, a);
if (n == 0) return {};
vector<T> ans(n + m - 1);
FOR(i, n) FOR(j, m) ans[i + j] += a[i] * b[j];
return ans;
}
template <class T, typename enable_if<has_mod<T>::value>::type* = nullptr>
vc<T> convolution_naive(const vc<T>& a, const vc<T>& b) {
int n = int(a.size()), m = int(b.size());
if (n > m) return convolution_naive<T>(b, a);
if (n == 0) return {};
vc<T> ans(n + m - 1);
if (n <= 16 && (T::get_mod() < (1 << 30))) {
for (int k = 0; k < n + m - 1; ++k) {
int s = max(0, k - m + 1);
int t = min(n, k + 1);
u64 sm = 0;
for (int i = s; i < t; ++i) { sm += u64(a[i].val) * (b[k - i].val); }
ans[k] = sm;
}
} else {
for (int k = 0; k < n + m - 1; ++k) {
int s = max(0, k - m + 1);
int t = min(n, k + 1);
u128 sm = 0;
for (int i = s; i < t; ++i) { sm += u64(a[i].val) * (b[k - i].val); }
ans[k] = T::raw(sm % T::get_mod());
}
}
return ans;
}
#line 2 "poly/convolution_karatsuba.hpp"
// 任意の環でできる
template <typename T>
vc<T> convolution_karatsuba(const vc<T>& f, const vc<T>& g) {
const int thresh = 30;
if (min(len(f), len(g)) <= thresh) return convolution_naive(f, g);
int n = max(len(f), len(g));
int m = ceil(n, 2);
vc<T> f1, f2, g1, g2;
if (len(f) < m) f1 = f;
if (len(f) >= m) f1 = {f.begin(), f.begin() + m};
if (len(f) >= m) f2 = {f.begin() + m, f.end()};
if (len(g) < m) g1 = g;
if (len(g) >= m) g1 = {g.begin(), g.begin() + m};
if (len(g) >= m) g2 = {g.begin() + m, g.end()};
vc<T> a = convolution_karatsuba(f1, g1);
vc<T> b = convolution_karatsuba(f2, g2);
FOR(i, len(f2)) f1[i] += f2[i];
FOR(i, len(g2)) g1[i] += g2[i];
vc<T> c = convolution_karatsuba(f1, g1);
vc<T> F(len(f) + len(g) - 1);
assert(2 * m + len(b) <= len(F));
FOR(i, len(a)) F[i] += a[i], c[i] -= a[i];
FOR(i, len(b)) F[2 * m + i] += b[i], c[i] -= b[i];
if (c.back() == T(0)) c.pop_back();
FOR(i, len(c)) if (c[i] != T(0)) F[m + i] += c[i];
return F;
}
#line 2 "poly/ntt.hpp"
template <class mint>
void ntt(vector<mint>& a, bool inverse) {
assert(mint::can_ntt());
const int rank2 = mint::ntt_info().fi;
const u32 mod = mint::get_mod();
static array<mint, 30> root, iroot;
static array<mint, 30> rate2, irate2;
static array<mint, 30> rate3, irate3;
assert(rank2 != -1 && len(a) <= (1 << max(0, rank2)));
static bool prepared = 0;
if (!prepared) {
prepared = 1;
root[rank2] = mint::ntt_info().se;
iroot[rank2] = mint(1) / root[rank2];
FOR_R(i, rank2) {
root[i] = root[i + 1] * root[i + 1];
iroot[i] = iroot[i + 1] * iroot[i + 1];
}
mint prod = 1, iprod = 1;
for (int i = 0; i <= rank2 - 2; i++) {
rate2[i] = root[i + 2] * prod;
irate2[i] = iroot[i + 2] * iprod;
prod *= iroot[i + 2];
iprod *= root[i + 2];
}
prod = 1, iprod = 1;
for (int i = 0; i <= rank2 - 3; i++) {
rate3[i] = root[i + 3] * prod;
irate3[i] = iroot[i + 3] * iprod;
prod *= iroot[i + 3];
iprod *= root[i + 3];
}
}
int n = int(a.size());
int h = topbit(n);
assert(n == 1 << h);
if (!inverse) {
int len = 0;
while (len < h) {
if (h - len == 1) {
int p = 1 << (h - len - 1);
mint rot = 1;
FOR(s, 1 << len) {
int offset = s << (h - len);
FOR(i, p) {
auto l = a[i + offset];
auto r = a[i + offset + p] * rot;
a[i + offset] = l + r;
a[i + offset + p] = l - r;
}
rot *= rate2[topbit(~s & -~s)];
}
len++;
} else {
int p = 1 << (h - len - 2);
mint rot = 1, imag = root[2];
for (int s = 0; s < (1 << len); s++) {
mint rot2 = rot * rot;
mint rot3 = rot2 * rot;
int offset = s << (h - len);
for (int i = 0; i < p; i++) {
u64 mod2 = u64(mod) * mod;
u64 a0 = a[i + offset].val;
u64 a1 = u64(a[i + offset + p].val) * rot.val;
u64 a2 = u64(a[i + offset + 2 * p].val) * rot2.val;
u64 a3 = u64(a[i + offset + 3 * p].val) * rot3.val;
u64 a1na3imag = (a1 + mod2 - a3) % mod * imag.val;
u64 na2 = mod2 - a2;
a[i + offset] = a0 + a2 + a1 + a3;
a[i + offset + 1 * p] = a0 + a2 + (2 * mod2 - (a1 + a3));
a[i + offset + 2 * p] = a0 + na2 + a1na3imag;
a[i + offset + 3 * p] = a0 + na2 + (mod2 - a1na3imag);
}
rot *= rate3[topbit(~s & -~s)];
}
len += 2;
}
}
} else {
mint coef = mint(1) / mint(len(a));
FOR(i, len(a)) a[i] *= coef;
int len = h;
while (len) {
if (len == 1) {
int p = 1 << (h - len);
mint irot = 1;
FOR(s, 1 << (len - 1)) {
int offset = s << (h - len + 1);
FOR(i, p) {
u64 l = a[i + offset].val;
u64 r = a[i + offset + p].val;
a[i + offset] = l + r;
a[i + offset + p] = (mod + l - r) * irot.val;
}
irot *= irate2[topbit(~s & -~s)];
}
len--;
} else {
int p = 1 << (h - len);
mint irot = 1, iimag = iroot[2];
FOR(s, (1 << (len - 2))) {
mint irot2 = irot * irot;
mint irot3 = irot2 * irot;
int offset = s << (h - len + 2);
for (int i = 0; i < p; i++) {
u64 a0 = a[i + offset + 0 * p].val;
u64 a1 = a[i + offset + 1 * p].val;
u64 a2 = a[i + offset + 2 * p].val;
u64 a3 = a[i + offset + 3 * p].val;
u64 x = (mod + a2 - a3) * iimag.val % mod;
a[i + offset] = a0 + a1 + a2 + a3;
a[i + offset + 1 * p] = (a0 + mod - a1 + x) * irot.val;
a[i + offset + 2 * p] = (a0 + a1 + 2 * mod - a2 - a3) * irot2.val;
a[i + offset + 3 * p] = (a0 + 2 * mod - a1 - x) * irot3.val;
}
irot *= irate3[topbit(~s & -~s)];
}
len -= 2;
}
}
}
}
#line 9 "poly/convolution.hpp"
template <class mint>
vector<mint> convolution_ntt(vector<mint> a, vector<mint> b) {
assert(mint::can_ntt());
if (a.empty() || b.empty()) return {};
int n = int(a.size()), m = int(b.size());
int sz = 1;
while (sz < n + m - 1) sz *= 2;
// sz = 2^k のときの高速化。分割統治的なやつで損しまくるので。
if ((n + m - 3) <= sz / 2) {
auto a_last = a.back(), b_last = b.back();
a.pop_back(), b.pop_back();
auto c = convolution(a, b);
c.resize(n + m - 1);
c[n + m - 2] = a_last * b_last;
FOR(i, len(a)) c[i + len(b)] += a[i] * b_last;
FOR(i, len(b)) c[i + len(a)] += b[i] * a_last;
return c;
}
a.resize(sz), b.resize(sz);
bool same = a == b;
ntt(a, 0);
if (same) {
b = a;
} else {
ntt(b, 0);
}
FOR(i, sz) a[i] *= b[i];
ntt(a, 1);
a.resize(n + m - 1);
return a;
}
template <typename mint>
vector<mint> convolution_garner(const vector<mint>& a, const vector<mint>& b) {
int n = len(a), m = len(b);
if (!n || !m) return {};
static constexpr int p0 = 167772161;
static constexpr int p1 = 469762049;
static constexpr int p2 = 754974721;
using mint0 = modint<p0>;
using mint1 = modint<p1>;
using mint2 = modint<p2>;
vc<mint0> a0(n), b0(m);
vc<mint1> a1(n), b1(m);
vc<mint2> a2(n), b2(m);
FOR(i, n) a0[i] = a[i].val, a1[i] = a[i].val, a2[i] = a[i].val;
FOR(i, m) b0[i] = b[i].val, b1[i] = b[i].val, b2[i] = b[i].val;
auto c0 = convolution_ntt<mint0>(a0, b0);
auto c1 = convolution_ntt<mint1>(a1, b1);
auto c2 = convolution_ntt<mint2>(a2, b2);
vc<mint> c(len(c0));
FOR(i, n + m - 1) {
c[i] = CRT3<mint, p0, p1, p2>(c0[i].val, c1[i].val, c2[i].val);
}
return c;
}
vector<ll> convolution(vector<ll> a, vector<ll> b) {
int n = len(a), m = len(b);
if (!n || !m) return {};
if (min(n, m) <= 2500) return convolution_naive(a, b);
ll mi_a = MIN(a), mi_b = MIN(b);
for (auto& x : a) x -= mi_a;
for (auto& x : b) x -= mi_b;
assert(MAX(a) * MAX(b) <= 1e18);
auto Ac = cumsum<ll>(a), Bc = cumsum<ll>(b);
vi res(n + m - 1);
for (int k = 0; k < n + m - 1; ++k) {
int s = max(0, k - m + 1);
int t = min(n, k + 1);
res[k] += (t - s) * mi_a * mi_b;
res[k] += mi_a * (Bc[k - s + 1] - Bc[k - t + 1]);
res[k] += mi_b * (Ac[t] - Ac[s]);
}
static constexpr u32 MOD1 = 1004535809;
static constexpr u32 MOD2 = 1012924417;
using mint1 = modint<MOD1>;
using mint2 = modint<MOD2>;
vc<mint1> a1(n), b1(m);
vc<mint2> a2(n), b2(m);
FOR(i, n) a1[i] = a[i], a2[i] = a[i];
FOR(i, m) b1[i] = b[i], b2[i] = b[i];
auto c1 = convolution_ntt<mint1>(a1, b1);
auto c2 = convolution_ntt<mint2>(a2, b2);
FOR(i, n + m - 1) { res[i] += CRT2<u64, MOD1, MOD2>(c1[i].val, c2[i].val); }
return res;
}
template <typename mint>
vc<mint> convolution(const vc<mint>& a, const vc<mint>& b) {
if (mint::get_mod() == 2) {
vc<modint998> aa, bb;
for (auto& x : a) aa.eb(x.val);
for (auto& x : b) bb.eb(x.val);
aa = convolution<modint998>(aa, bb);
vc<mint> ANS(len(aa));
FOR(i, len(aa)) ANS[i] = aa[i].val & 1;
return ANS;
}
int n = len(a), m = len(b);
if (!n || !m) return {};
if (mint::can_ntt()) {
if (min(n, m) <= 50) return convolution_karatsuba<mint>(a, b);
return convolution_ntt(a, b);
}
if (min(n, m) <= 200) return convolution_karatsuba<mint>(a, b);
return convolution_garner(a, b);
}
#line 4 "poly/fps_inv.hpp"
template <typename mint>
vc<mint> fps_inv_sparse(const vc<mint>& f) {
int N = len(f);
vc<pair<int, mint>> dat;
FOR(i, 1, N) if (f[i] != mint(0)) dat.eb(i, f[i]);
vc<mint> g(N);
mint g0 = mint(1) / f[0];
g[0] = g0;
FOR(n, 1, N) {
mint rhs = 0;
for (auto&& [k, fk]: dat) {
if (k > n) break;
rhs -= fk * g[n - k];
}
g[n] = rhs * g0;
}
return g;
}
template <typename mint>
vc<mint> fps_inv_dense_ntt(const vc<mint>& F) {
vc<mint> G = {mint(1) / F[0]};
ll N = len(F), n = 1;
G.reserve(N);
while (n < N) {
vc<mint> f(2 * n), g(2 * n);
FOR(i, min(N, 2 * n)) f[i] = F[i];
FOR(i, n) g[i] = G[i];
ntt(f, false), ntt(g, false);
FOR(i, 2 * n) f[i] *= g[i];
ntt(f, true);
FOR(i, n) f[i] = 0;
ntt(f, false);
FOR(i, 2 * n) f[i] *= g[i];
ntt(f, true);
FOR(i, n, min(N, 2 * n)) G.eb(-f[i]);
n *= 2;
}
return G;
}
template <typename mint>
vc<mint> fps_inv_dense(const vc<mint>& F) {
if (mint::can_ntt()) return fps_inv_dense_ntt(F);
const int N = len(F);
vc<mint> R = {mint(1) / F[0]};
vc<mint> p;
int m = 1;
while (m < N) {
p = convolution(R, R);
p.resize(m + m);
vc<mint> f = {F.begin(), F.begin() + min(m + m, N)};
p = convolution(p, f);
R.resize(m + m);
FOR(i, m + m) R[i] = R[i] + R[i] - p[i];
m += m;
}
R.resize(N);
return R;
}
template <typename mint>
vc<mint> fps_inv(const vc<mint>& f) {
assert(f[0] != mint(0));
int n = count_terms(f);
int t = (mint::can_ntt() ? 160 : 820);
return (n <= t ? fps_inv_sparse<mint>(f) : fps_inv_dense<mint>(f));
}
#line 4 "poly/poly_divmod.hpp"
template <typename mint>
pair<vc<mint>, vc<mint>> poly_divmod(vc<mint> f, vc<mint> g) {
assert(g.back() != 0);
if (len(f) < len(g)) { return {{}, f}; }
auto rf = f, rg = g;
reverse(all(rf)), reverse(all(rg));
ll deg = len(rf) - len(rg) + 1;
rf.resize(deg), rg.resize(deg);
rg = fps_inv(rg);
auto q = convolution(rf, rg);
q.resize(deg);
reverse(all(q));
auto h = convolution(q, g);
FOR(i, len(f)) f[i] -= h[i];
while (len(f) > 0 && f.back() == 0) f.pop_back();
return {q, f};
}
#line 2 "poly/poly_gcd.hpp"
// https://people.eecs.berkeley.edu/~fateman/282/readings/yap-2.pdf
namespace half_gcd {
template <typename T>
using arr = array<vc<T>, 2>;
template <typename T>
using mat = array<vc<T>, 4>;
template <typename T>
void shrink(vc<T>& a) {
while (len(a) && a.back() == 0) a.pop_back();
}
template <typename T>
vc<T> operator+(const vc<T>& a, const vc<T>& b) {
vc<T> c(max(len(a), len(b)));
FOR(i, len(a)) c[i] += a[i];
FOR(i, len(b)) c[i] += b[i];
shrink(c);
return c;
}
template <typename T>
vc<T> operator-(const vc<T>& a, const vc<T>& b) {
vc<T> c(max(len(a), len(b)));
FOR(i, len(a)) c[i] += a[i];
FOR(i, len(b)) c[i] -= b[i];
shrink(c);
return c;
}
template <typename T>
vc<T> operator*(const vc<T>& a, const vc<T>& b) {
return convolution(a, b);
}
template <typename T>
mat<T> operator*(const mat<T>& A, const mat<T>& B) {
return {A[0] * B[0] + A[1] * B[2], A[0] * B[1] + A[1] * B[3],
A[2] * B[0] + A[3] * B[2], A[2] * B[1] + A[3] * B[3]};
}
template <typename T>
mat<T> step(const vc<T> q) {
mat<T> Q;
Q[1] = {1}, Q[2] = {1};
Q[3] = Q[3] - q;
return Q;
}
template <typename T>
arr<T> operator*(const mat<T>& A, const arr<T>& b) {
return {A[0] * b[0] + A[1] * b[1], A[2] * b[0] + A[3] * b[1]};
}
template <typename T>
mat<T> hgcd(arr<T> a) {
assert(len(a[0]) > len(a[1]) && len(a[1]) > 0);
int m = len(a[0]) / 2;
if (len(a[1]) <= m) {
mat<T> M;
M[0] = {1}, M[3] = {1};
return M;
}
auto R = hgcd(arr<T>({vc<T>(a[0].begin() + m, a[0].end()),
vc<T>(a[1].begin() + m, a[1].end())}));
a = R * a;
if (len(a[1]) <= m) return R;
mat<T> Q = step(poly_divmod(a[0], a[1]).fi);
R = Q * R, a = Q * a;
if (len(a[1]) <= m) return R;
int k = 2 * m + 1 - len(a[0]);
auto H = hgcd(arr<T>({vc<T>(a[0].begin() + k, a[0].end()),
vc<T>(a[1].begin() + k, a[1].end())}));
return H * R;
}
template <typename T>
mat<T> cgcd(arr<T> a) {
assert(a[0].size() > a[1].size() && !a[1].empty());
auto m0 = hgcd(a);
a = m0 * a;
if (a[1].empty()) return m0;
mat<T> Q = step(poly_divmod(a[0], a[1]).fi);
m0 = Q * m0, a = Q * a;
if (a[1].empty()) return m0;
return cgcd(a) * m0;
}
// gcd == f * fi + g * gi となる (gcd, fi, gi)
template <typename T>
tuple<vc<T>, vc<T>, vc<T>> poly_extgcd(const vc<T>& f, const vc<T>& g) {
mat<T> Q = step(poly_divmod(f, g).fi);
auto m = Q;
auto ap = Q * arr<T>{f, g};
if (!ap[1].empty()) m = cgcd(ap) * m;
return {f * m[0] + g * m[1], m[0], m[1]};
}
template <typename T>
vc<T> poly_gcd(vc<T> f, vc<T> g) {
while (len(f) && f.back() == T(0)) POP(f);
while (len(g) && g.back() == T(0)) POP(g);
if (f.empty()) return g;
if (g.empty()) return f;
auto F = get<0>(poly_extgcd(f, g));
T c = T(1) / F.back();
for (auto& f: F) f *= c;
return F;
}
} // namespace half_gcd
using half_gcd::poly_extgcd;
using half_gcd::poly_gcd;
#line 4 "seq/find_linear_rec.hpp"
// template <typename mint>
// vector<mint> find_linear_rec(vector<mint>& A) {
// int N = len(A);
// vc<mint> B = {1}, C = {1};
// int l = 0, m = 1;
// mint p = 1;
// FOR(i, N) {
// mint d = A[i];
// FOR3(j, 1, l + 1) { d += C[j] * A[i - j]; }
// if (d == 0) {
// ++m;
// continue;
// }
// auto tmp = C;
// mint q = d / p;
// if (len(C) < len(B) + m) C.insert(C.end(), len(B) + m - len(C), 0);
// FOR(j, len(B)) C[j + m] -= q * B[j];
// if (l + l <= i) {
// B = tmp;
// l = i + 1 - l, m = 1;
// p = d;
// } else {
// ++m;
// }
// }
// return C;
// }
namespace half_gcd {
template <typename T>
vector<T> find_linear_rec(vc<T>& F) {
vc<T> f = F;
int d = len(f);
reverse(all(f));
while (len(f) && f.back() == T(0)) POP(f);
if (f.empty()) return vc<T>{T(1)};
vc<T> g(d + 1);
g.back() = T(1);
auto m = hgcd(arr<T>{g, f});
auto a = m * arr<T>{g, f};
if (len(a[1]) > d - len(a[0]) + 1) m = step(poly_divmod(a[0], a[1]).fi) * m;
vc<T> Q = m[3];
T v = Q.back().inverse();
for (auto& x : Q) x *= v;
reverse(all(Q));
return Q;
}
}; // namespace half_gcd
using half_gcd::find_linear_rec;
#line 2 "random/base.hpp"
u64 RNG_64() {
static u64 x_ = u64(chrono::duration_cast<chrono::nanoseconds>(chrono::high_resolution_clock::now().time_since_epoch()).count()) * 10150724397891781847ULL;
x_ ^= x_ << 7;
return x_ ^= x_ >> 9;
}
u64 RNG(u64 lim) { return RNG_64() % lim; }
ll RNG(ll l, ll r) { return l + RNG_64() % (r - l); }
#line 3 "linalg/blackbox/min_poly.hpp"
// 行列 A をかけることを表す線形変換 f を渡す
// auto f = [&](vc<mint> v) -> vc<mint> {};
template <typename mint, typename F>
vc<mint> blackbox_min_poly(int N, F f) {
vc<mint> S(N + N + 10);
vc<mint> c(N);
vc<mint> v(N);
FOR(i, N) c[i] = RNG(0, mint::get_mod());
FOR(i, N) v[i] = RNG(0, mint::get_mod());
FOR(k, N + N + 10) {
FOR(i, N) S[k] += c[i] * v[i];
v = f(v);
}
S = find_linear_rec(S);
reverse(all(S));
return S;
}
#line 2 "linalg/blackbox/det.hpp"
template <typename mint, typename F>
mint blackbox_det(int N, F apply) {
vc<mint> c(N);
FOR(i, N) c[i] = RNG(1, mint::get_mod());
mint r = 1;
FOR(i, N) r *= c[i];
auto g = [&](vc<mint> v) -> vc<mint> {
FOR(i, N) v[i] *= c[i];
return apply(v);
};
auto f = blackbox_min_poly<mint>(N, g);
mint det = (len(f) == N + 1 ? f[0] : mint(0));
if (N & 1) det *= -1;
det /= r;
return det;
}
#line 2 "mod/barrett.hpp"
// https://github.com/atcoder/ac-library/blob/master/atcoder/internal_math.hpp
struct Barrett {
u32 m;
u64 im;
explicit Barrett(u32 m = 1) : m(m), im(u64(-1) / m + 1) {}
u32 umod() const { return m; }
u32 modulo(u64 z) {
if (m == 1) return 0;
u64 x = (u64)(((unsigned __int128)(z)*im) >> 64);
u64 y = x * m;
return (z - y + (z < y ? m : 0));
}
u64 floor(u64 z) {
if (m == 1) return z;
u64 x = (u64)(((unsigned __int128)(z)*im) >> 64);
u64 y = x * m;
return (z < y ? x - 1 : x);
}
pair<u64, u32> divmod(u64 z) {
if (m == 1) return {z, 0};
u64 x = (u64)(((unsigned __int128)(z)*im) >> 64);
u64 y = x * m;
if (z < y) return {x - 1, z - y + m};
return {x, z - y};
}
u32 mul(u32 a, u32 b) { return modulo(u64(a) * b); }
};
struct Barrett_64 {
u128 mod, mh, ml;
explicit Barrett_64(u64 mod = 1) : mod(mod) {
u128 m = u128(-1) / mod;
if (m * mod + mod == u128(0)) ++m;
mh = m >> 64;
ml = m & u64(-1);
}
u64 umod() const { return mod; }
u64 modulo(u128 x) {
u128 z = (x & u64(-1)) * ml;
z = (x & u64(-1)) * mh + (x >> 64) * ml + (z >> 64);
z = (x >> 64) * mh + (z >> 64);
x -= z * mod;
return x < mod ? x : x - mod;
}
u64 mul(u64 a, u64 b) { return modulo(u128(a) * b); }
};
#line 2 "linalg/det.hpp"
int det_mod(vvc<int> A, int mod) {
Barrett bt(mod);
const int n = len(A);
ll det = 1;
FOR(i, n) FOR(j, n) {
if (A[i][j] < 0) A[i][j] += mod;
}
FOR(i, n) {
FOR(j, i, n) {
if (A[j][i] == 0) continue;
if (i != j) {
swap(A[i], A[j]), det = mod - det;
}
break;
}
FOR(j, i + 1, n) {
while (A[i][i] != 0) {
ll c = mod - A[j][i] / A[i][i];
FOR_R(k, i, n) { A[j][k] = bt.modulo(A[j][k] + A[i][k] * c); }
swap(A[i], A[j]), det = mod - det;
}
swap(A[i], A[j]), det = mod - det;
}
}
FOR(i, n) det = bt.mul(det, A[i][i]);
return det % mod;
}
template <typename mint>
mint det(vvc<mint>& A) {
const int n = len(A);
vv(int, B, n, n);
FOR(i, n) FOR(j, n) B[i][j] = A[i][j].val;
return det_mod(B, mint::get_mod());
}
#line 4 "graph/count/BEST.hpp"
/*
ひとつ選んだ辺から始めて全ての辺を通る closed walk を数える.
多重辺は vc<int>(eid) で渡す，なければすべて 1. e.cost は参照しない.
辺はラベル付きで考える. 多重辺を同一視する場合などは後で階乗で割ること.
O(N^2+NM) （ + 最後に重複度の階乗をかける）．
*/
template <typename mint, bool sparse, typename GT>
mint BEST_theorem(GT G, vc<int> edge_multiplicity = {}) {
static_assert(GT::is_directed);
int N = G.N, M = G.M;
if (M == 0) return 0;
if (edge_multiplicity.empty()) edge_multiplicity.assign(M, 1);
vc<int> vs;
for (auto& e: G.edges) {
if (edge_multiplicity[e.id] == 0) continue;
vs.eb(e.frm), vs.eb(e.to);
}
UNIQUE(vs);
G = G.rearrange(vs, true);
N = G.N;
vc<int> indeg(N), outdeg(N);
if constexpr (sparse) {
vc<tuple<int, int, mint>> mat;
for (auto& e: G.edges) {
int a = e.frm, b = e.to, x = edge_multiplicity[e.id];
outdeg[a] += x, indeg[b] += x;
if (a < N - 1 && b < N - 1) mat.eb(a, b, -x);
if (a < N - 1) mat.eb(a, a, x);
}
FOR(v, N) if (indeg[v] != outdeg[v]) return 0;
auto apply = [&](vc<mint> A) -> vc<mint> {
vc<mint> B(N - 1);
for (auto& [a, b, c]: mat) B[b] += A[a] * c;
return B;
};
mint d = blackbox_det<mint>(N - 1, apply);
for (auto& x: outdeg) { d *= fact<mint>(x - 1); }
return d;
} else {
// dense
vv(mint, mat, N - 1, N - 1);
for (auto& e: G.edges) {
int a = e.frm, b = e.to, x = edge_multiplicity[e.id];
outdeg[a] += x, indeg[b] += x;
if (a < N - 1 && b < N - 1) mat[a][b] -= x;
if (a < N - 1) mat[a][a] += x;
}
FOR(v, N) if (indeg[v] != outdeg[v]) return 0;
mint d = det(mat);
for (auto& x: outdeg) { d *= fact<mint>(x - 1); }
return d;
}
}