多项式不全家桶

多项式不全家桶(暂不更新)

前置知识需要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;
}
posted @ 2020-12-31 07:04  longdie  阅读(331)  评论(1编辑  收藏  举报