多项式不全家桶
多项式不全家桶（暂不更新）
前置知识需要FFT和NTT。
多项式求逆
板子题链接
求逆指的是给定一个多项式 \(F(x)\)，你需要求出一个多项式 \(G(x)\)，使其满足 \(F(x) * G(x)\equiv1\pmod {x^n}\)
考虑为什么要在 \(\pmod {x^n}\) 情况下来求解，其实多项式可以近似理解为级数，显然级数的项数是无穷的，所以我们用 \(\pmod {x^n}\) 来使得这个多项式的项数有穷。（大致理解就行）
首先大致的思路是分治解决问题。
显然的如果多项式只有 \(1\) 项，那么解就是其逆元。
我们考虑从原式在 mod \(x^{\lceil\frac n 2\rceil}\) 的推到 mod \(x^ n\) 的情 况：
\[F(x)* G_1(x)\equiv1\pmod {x^{\lceil\frac n 2\rceil}}
\]
其中 \(G_1(x)\) 指在 \(\pmod {x^{\lceil\frac n 2\rceil}}\) 的情况下的解，\(G(x)\) 指在 \(\pmod {x^n}\) 的情况下的解。
那么也有：
\[F(x)* G(x)\equiv1\pmod {x^{\lceil\frac n 2\rceil}}
\]
两个式子相减可以得到：
\[G_1(x)-G(x)\equiv0\pmod{x^{\lceil\frac n 2\rceil}}
\]
平方得 ：
\[G_1^{2}(x)-2G_1(x)G(x)+G^2(x)\equiv0\pmod{x^n}
\]
两边同乘多项式 \(F(x)\) 得：
\[F(x) * G_1^{2}(x) - 2G_1(x) + G(x)\equiv0\pmod{x^n}
\]
移项显然得：
\[G(x)\equiv(2-F(x)G_1(x))G_1(x)\pmod{x^n}
\]
然后你发现右边的东西已经可以计算了。
复杂度非常显然的 \(O(nlogn)\)
但是需要注意几个问题，我会在代码里写出来。
代码
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5, mod = 998244353, g1 = 3, g2 = (mod + 1) / 3;
int n, a[N], b[N], d[N], A[N], B[N];
inline int qpow(int a, int b, int res = 1) {
for(; b; b >>= 1, a = 1ll * a * a % mod)
if(b & 1) res = 1ll * res * a % mod;
return res;
}
void NTT(int *a, int flag, int len) {
for(register int i = 0; i < len; ++i) if(i < d[i]) swap(a[i], a[d[i]]);
for(register int l = 2, m = 1; l <= len; l <<= 1, m <<= 1) {
int w1 = qpow(flag == 1 ? g1 : g2, (mod - 1) / l);
for(register int *p = a; p != a + len; p += l) {
int w = 1;
for(register int i = 0; i < m; ++i, w = 1ll*w*w1%mod) {
int t = 1ll * w * p[i + m] % mod;
p[i + m] = (p[i] - t + mod) % mod, p[i] = (p[i] + t) % mod;
}
}
}
}
void niyuan(int *a, int *b, int n) {
memset(A, 0, n * 16), memset(B, 0, n * 16);//如果需要多次计算的话，别忘了清零
b[0] = qpow(a[0], mod - 2);
for(register int l = 2, m = 1; l <= n << 2; l <<= 1, m <<= 1) {//注意我们需要跑到 l < n * 4，即4倍
for(register int i = 0; i < m; ++i) A[i] = a[i], B[i] = b[i];
for(register int i = 0; i < l; ++i) d[i] = (d[i>>1] >> 1) | ((i & 1) ? m : 0);
NTT(A, 1, l), NTT(B, 1, l);
for(register int i = 0; i < l; ++i) b[i] = ((2ll - 1ll*A[i]*B[i]%mod) * B[i] % mod + mod) % mod;
NTT(b, -1, l);
int ni = qpow(l, mod - 2);
for(register int i = 0; i < l; ++i) b[i] = 1ll * b[i] * ni % mod;
for(register int i = m; i < l; ++i) b[i] = 0;//为什么每次需要清零，主要是由推导的式子决定的。
}
}
int main() {
scanf("%d", &n);
for(register int i = 0; i < n; ++i) scanf("%d", &a[i]);
niyuan(a, b, n);
for(register int i = 0; i < n; ++i) printf("%d ", b[i]);
return 0;
}
多项式开根
多项式开根是已知多项式 \(A(x)\) ，在 \(\pmod {x^n}\) 的条件下，求得一个多项式 \(B(x)\)，使得 \(B^2(x) = A(x) \equiv1\pmod {x^n}\) 。
我们依旧采用分治的思想进行解决。
一般我们习惯设 \(B(x)\) 的常数项为 1，这样主要是为了方便计算。
我们考虑从原式在 mod \(x^{\lceil\frac n 2\rceil}\) 的推到 mod \(x^ n\) 的情 况：
\[B^2(x)\equiv A(x) (mod\ x^{n})
\]
设多项式 \(B'^2(x)\) 为在 \((mod\ x^{\frac{n}{2}})\) 的情况下的解，
那么：
\[B'^2(x)\equiv A(x) (mod\ x^{\frac{n}{2}})
\]
然后两个式子相减得到 ：
\[B(x)-B'(x)\equiv 0(mod\ x^{\frac{n}{2}})
\]
然后平方得 ：
\[A(x)-2B(x)B'(x)+B'^2(x)\equiv 0(mod\ x^n)
\]
最后移项得 ：
\[B(x)\equiv \dfrac{A(x)+B'^2(x)}{2B'(x)} (mod\ x^n)
\]
非常显然的右边的式子可以用求逆和乘法解决掉。
复杂度 \(O(nlogn)\)
代码
#include <bits/stdc++.h>
using namespace std;
const int N = 8e5 + 5, mod = 998244353, g1 = 3, g2 = (mod + 1) / 3, ni2 = (mod + 1) / 2;
int n, a[N], b[N], d[N], A[N], B[N], inv[N], c[N];
inline int qpow(int a, int b, int res = 1) {
for(; b; b >>= 1, a = 1ll * a * a % mod)
if(b & 1) res = 1ll * res * a % mod;
return res;
}
void NTT(int *a, int flag, int len) {
for(register int i = 0; i < len; ++i) if(i < d[i]) swap(a[i], a[d[i]]);
for(register int l = 2, m = 1; l <= len; l <<= 1, m <<= 1) {
int w1 = qpow(flag == 1 ? g1 : g2, (mod - 1) / l);
for(register int *p = a; p != a + len; p += l) {
int w = 1;
for(register int i = 0; i < m; ++i, w = 1ll*w*w1%mod) {
int t = 1ll * w * p[i + m] % mod;
p[i + m] = (p[i] - t + mod) % mod, p[i] = (p[i] + t) % mod;
}
}
}
}
void niyuan(int *a, int *b, int n) {
memset(A, 0, n * 16), memset(B, 0, n * 16);
b[0] = qpow(a[0], mod - 2);
for(register int l = 2, m = 1; l < n << 2; l <<= 1, m <<= 1) {
for(register int i = 0; i < m; ++i) A[i] = a[i], B[i] = b[i];
for(register int i = 0; i < l; ++i) d[i] = (d[i>>1] >> 1) | ((i & 1) ? m : 0);
NTT(A, 1, l), NTT(B, 1, l);
for(register int i = 0; i < l; ++i) b[i] = ((2ll - 1ll*A[i]*B[i]%mod) * B[i] % mod + mod) % mod;
NTT(b, -1, l);
int ni = qpow(l, mod - 2);
for(register int i = 0; i < l; ++i) b[i] = 1ll * b[i] * ni % mod;
for(register int i = m; i < l; ++i) b[i] = 0;
}
}
void kaigen(int *a, int *b, int n) {
memset(c, 0, n * 16), memset(inv, 0, n * 16);
b[0] = 1;//默认
for(register int l = 2, m = 1; l < n << 2; l <<= 1, m <<= 1) {
for(register int i = 0; i < m; ++i) c[i] = a[i];
niyuan(b, inv, m);
for(register int i = 0; i < l; ++i) d[i] = (d[i>>1] >> 1) | ((i&1) ? m : 0);
NTT(c, 1, l), NTT(inv, 1, l);
for(register int i = 0; i < l; ++i) c[i] = 1ll * c[i] * inv[i] % mod;
NTT(c, -1, l);
int ni = qpow(l, mod - 2);
for(register int i = 0; i < l; ++i) c[i] = 1ll * c[i] * ni % mod;
for(register int i = 0; i < m; ++i) b[i] = 1ll * ni2 * ((b[i] + c[i])%mod) % mod;
}
}
int main() {
scanf("%d", &n);
for(register int i = 0; i < n; ++i) scanf("%d", &a[i]);
kaigen(a, b, n);
for(register int i = 0; i < n; ++i) printf("%d ", b[i]);
return 0;
}
多项式求导与积分
求导 : 多项式求导的话一定会使它的次数降低。
多项式求导可以近似理解为对于多项式的每一项分别求导，幂函数的求导公式就是 \(f'(x^n) = n* x^{n-1}\) 。
所以多项式求导的代码也就大致出来了：
void qiudao(int *a, int *b, int n) {
for(register int i = 1; i < n; ++i) b[i-1] = 1ll * i * a[i] % mod; b[n-1] = 0;
}
积分：
反正我只知道积分可以大概理解为是求导的逆运算，而且我也不会算，所以直接告诉你代码吧（其实可以从求逆的角度理解）：
void jifen(int *a, int *b, int n) {
for(register int i = 1; i < n; ++i) b[i] = 1ll * a[i-1] * qpow(i, mod - 2) % mod; b[0] = 0;
}
注意积分不能把常数项求出来，所以我们默认为0。
多项式对数函数（多项式 ln）
已知多项式 \(A(x)\)，我们需要求出一个多项式使其满足 \(B(x) = lnA(x)\)。
下面开始推式子，首先我们对两边分别求导：
\[B(x) = lnA(x)
\]
\[B'(x) = \frac{A'(x)}{A(x)}
\]
右边的式子我们可以理解为复合函数的求导展开。
然后我们发现右边的式子很可做。
然后我们就可以得到 \(B'(x)\)，最后在积分一下就得到了 \(B(x)\)。
代码
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5, mod = 998244353, g1 = 3, g2 = (mod + 1) / 3;
int n, a[N], b[N], A[N], B[N], c[N], inv[N], d[N];
int qpow(int a, int b, int res = 1) {
for(; b; b >>= 1, a = 1ll * a * a % mod)
if(b & 1) res = 1ll * res * a % mod;
return res;
}
void NTT(int *a, int flag, int len) {
for(register int i = 0; i < len; ++i) if(i < d[i]) swap(a[i], a[d[i]]);
for(register int l = 2, m = 1; l <= len; l <<= 1, m <<= 1) {
int w1 = qpow(flag == 1 ? g1 : g2, (mod-1) / l);
for(register int *p = a; p != a + len; p += l) {
int w = 1;
for(register int i = 0; i < m; ++i, w = 1ll*w*w1%mod) {
int t = 1ll * w * p[i + m] % mod;
p[i + m] = (p[i] - t + mod) % mod;
p[i] = (p[i] + t) % mod;
}
}
}
}
void qiuni(int *a, int *b, int n) {
memset(A, 0, n * 16), memset(B, 0, n * 16);
b[0] = qpow(a[0], mod - 2);
for(register int l = 2, m = 1; l < n << 2; l <<= 1, m <<= 1) {
for(register int i = 0; i < m; ++i) A[i] = a[i], B[i] = b[i];
for(register int i = 0; i < l; ++i) d[i] = (d[i>>1] >> 1) | ((i&1) ? m : 0);
NTT(A, 1, l), NTT(B, 1, l);
for(register int i = 0; i < l; ++i) b[i] = ((2ll - 1ll*A[i]*B[i]%mod) * B[i] % mod + mod) % mod;
NTT(b, -1, l);
int ni = qpow(l, mod - 2);
for(register int i = 0; i < l; ++i) b[i] = 1ll * b[i] * ni % mod;
for(register int i = m; i < l; ++i) b[i] = 0;
}
}
void qiudao(int *a, int *b, int n) {
for(register int i = 1; i < n; ++i) b[i-1] = 1ll * i * a[i] % mod; b[n-1] = 0;
}
void jifen(int *a, int *b, int n) {
for(register int i = 1; i < n; ++i) b[i] = 1ll * a[i-1] * qpow(i, mod - 2) % mod; b[0] = 0;
}
void loyin(int *a, int *b, int n) {
memset(c, 0, n * 16), memset(inv, 0, n * 16);
qiudao(a, c, n), qiuni(a, inv, n);
int len = 1;
while(len <= n*2) len <<= 1;
for(register int i = 0; i < len; ++i) d[i] = (d[i>>1] >> 1) | ((i&1) ? len >> 1 : 0);
NTT(c, 1, len), NTT(inv, 1, len);
for(register int i = 0; i < len; ++i) c[i] = 1ll * c[i] * inv[i] % mod;
NTT(c, -1, len);
int ni = qpow(len, mod - 2);
for(register int i = 0; i < len; ++i) c[i] = 1ll * c[i] * ni % mod;
jifen(c, b, n);
}
int main() {
scanf("%d", &n);
for(register int i = 0; i < n; ++i) scanf("%d", &a[i]);
loyin(a, b, n);
for(register int i = 0; i < n; ++i) printf("%d ", b[i]);
return 0;
}
分治FFT
分治FFT主要是解决这样一类自己会转移到自己的问题，比如给定多项式 \(A(x)\)，让你求出 \(B_i = \sum^{i}_{j = 1} B_{i-j} * A_j\)，边界 \(B_0 = 1\)。
这就是分治FFT主要解决的问题，主要的思想是利用CDQ分治的思想，每次计算左半变对于右半边的共享，这样复杂度是 \(O(nlog^2n)\)的。
其实其主要思想就是cdq分治，每次做一个卷积（乘法），好像不知道怎么解释啊，自己试一下，当然主要的细节问题是边界问题，就是每次做多项式乘法的边界问题，这个在代码里标注。
代码
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5, mod = 998244353, g1 = 3, g2 = (mod + 1) / 3;
int n, a[N], b[N], d[N], cdq1[N], cdq2[N];
int qpow(int a, int b, int res = 1) {
for(; b; b >>= 1, a = 1ll * a * a % mod)
if(b & 1) res = 1ll * res * a % mod;
return res;
}
void NTT(int *a, int flag, int len) {
for(register int i = 0; i < len; ++i) if(i < d[i]) swap(a[i], a[d[i]]);
for(register int l = 2, m = 1; l <= len; l <<= 1, m <<= 1) {
int w1 = qpow(flag == 1 ? g1 : g2, (mod-1) / l);
for(register int *p = a; p != a + len; p += l) {
int w = 1;
for(register int i = 0; i < m; ++i, w = 1ll*w*w1%mod) {
int t = 1ll * w * p[i + m] % mod;
p[i + m] = (p[i] - t + mod) % mod;
p[i] = (p[i] + t) % mod;
}
}
}
}
void fenzhi(int l, int r) {
if(l == r) return;
int mid = (l + r) / 2, len = r - l + 1;
fenzhi(l, mid);
int *A = cdq1, *B = cdq2;
memset(A, 0, len * 8), memset(B, 0, len * 8);//注意每次清空数组
for(register int i = l; i <= mid; ++i) A[i-l] = b[i];
for(register int i = 0; i < r-l+1; ++i) B[i] = a[i+1];
int n = 1;
while(n <= len) n <<= 1;//之所以不用到 n <= len << 1，是因为这是一个循环卷积。
for(register int i = 0; i < n; ++i) d[i] = (d[i>>1] >> 1) | ((i&1) ? n >> 1 : 0);
NTT(A, 1, n), NTT(B, 1, n);
for(register int i = 0; i < n; ++i) A[i] = 1ll * A[i] * B[i] % mod;
NTT(A, -1, n);
int ni = qpow(n, mod - 2);
for(register int i = 0; i < n; ++i) A[i] = 1ll * A[i] * ni % mod;
for(register int i = mid + 1; i <= r; ++i) b[i] = (b[i] + A[i-l-1]) % mod;//注意取值与边界
fenzhi(mid + 1, r);
}
int main() {
scanf("%d", &n), b[0] = 1;
for(register int i = 1; i < n; ++i) scanf("%d", &a[i]);
fenzhi(0, n-1);
for(register int i = 0; i < n; ++i) printf("%d ", b[i]);
return 0;
}
多项式指数函数（多项式 exp）
我为什么要先讲一个分治FFT，主要是因为我的exp是写的分治FFT，复杂度是 \(O(nlog^2n)\)，虽然复杂度比正解的 \(O(nlogn)\) 要慢一点，但是代码好写，比正解的代码码量少一半，而且因为正解的常数过于巨大，如果卡常不好的话，我这个更快，洛谷上的提交记录显示，我的代码是比大多数人的正解都快的，所以我选择写分治FFT。
显然 exp 是给你一个多项式 \(A(x)\)，让你求得一个多项式 \(B(x)\)，使其满足 \(e^{A(x)} = B(x)\) 。
显然我们接着推式子：
我们依旧对于左右两边求导：
\[B'(x) = A'(x) * e^{A(x)}
\]
替换得到 ：
\[B'(x) = A'(x) * B(x)
\]
我们直接积分求解得：
\[B(x) = \int A'(x) * B(x)
\]
然后我们可能觉得右边的式子没有什么思路，但是我们发现这个式子与分治FFT非常像，只不过是带了一个积分，但是多项式的积分公式也很好求，所以我们可以选择采用分治FFT的思路，注释在代码里。
代码
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5, mod = 998244353, g1 = 3, g2 = (mod + 1) / 3;
int n, a[N], b[N], d[N], cdq1[N], cdq2[N];
int qpow(int a, int b, int res = 1) {
for(; b; b >>= 1, a = 1ll * a * a % mod)
if(b & 1) res = 1ll * res * a % mod;
return res;
}
void NTT(int *a, int flag, int len) {
for(register int i = 0; i < len; ++i) if(i < d[i]) swap(a[i], a[d[i]]);
for(register int l = 2, m = 1; l <= len; l <<= 1, m <<= 1) {
int w1 = qpow(flag == 1 ? g1 : g2, (mod-1) / l);
for(register int *p = a; p != a + len; p += l) {
int w = 1;
for(register int i = 0; i < m; ++i, w = 1ll*w*w1%mod) {
int t = 1ll * w * p[i + m] % mod;
p[i + m] = (p[i] - t + mod) % mod;
p[i] = (p[i] + t) % mod;
}
}
}
}
void fenzhi(int l, int r) {
if(l == r) {
if(l) b[l] = 1ll * b[l] * qpow(l, mod - 2) % mod;//积分公式，乘一个逆元
else b[l] = 1;
return;
}
int mid = (l + r) / 2, len = r - l + 1;
fenzhi(l, mid);
int *A = cdq1, *B = cdq2;
int n = 1;
while(n < len) n <<= 1;
memset(A, 0, n * 4), memset(B, 0, n * 4);//其他的与分治FFT无任何区别
for(register int i = 0; i < n; ++i) d[i] = (d[i>>1] >> 1) | ((i&1) ? n >> 1 : 0);
for(register int i = l; i <= mid; ++i) A[i-l] = b[i];
for(register int i = 0; i < len; ++i) B[i] = a[i];
NTT(A, 1, n), NTT(B, 1, n);
for(register int i = 0; i < n; ++i) A[i] = 1ll * A[i] * B[i] % mod;
NTT(A, -1, n);
int ni = qpow(n, mod - 2);
for(register int i = 0; i < n; ++i) A[i] = 1ll * A[i] * ni % mod;
for(register int i = mid+1; i <= r; ++i) b[i] = (b[i] + A[i-l-1]) % mod;
fenzhi(mid + 1, r);
}
int main() {
scanf("%d", &n);
for(register int i = 0; i < n; ++i) scanf("%d", &a[i]);
for(register int i = 1; i < n; ++i) a[i-1] = 1ll * a[i] * i % mod; a[n-1] = 0;//求导
fenzhi(0, n-1);
for(register int i = 0; i < n; ++i) printf("%d ", b[i]);
return 0;
}
