飞飞兔家族

多项式

如何学习这些毒瘤？

背模板！......反正学了不久就忘光了，还是背模板来的实在。

1.FFT

快速傅里叶变换。一切的基础。

作用是在 点值式 与 系数式 之间进行转换。

首先我们要手写复数。

然后背下来这个预处理的东西：

r[i] = (r[i >> 1] >> 1) | ((i & 1) << (lm - 1));

把n补全为2的次幂，下界为 n + m + 1，数组开4倍以上。

然后注意把n补全之后的各个地方n的写法：

FFT中都是 < n，涉及要实际输出的是 <= n 

最后别忘了 / n，输出时 + 0.5，输出 [0, n + m]

中间也要记清楚，Wn = (cos(pi / len), f * sin(pi / len));

手写pi的精度高一些，3.1415926 5358979 32384626

FFT前记得置换。

上代码：

#include <cstdio>
#include <algorithm>
#include <cmath>
const int N = 1000010;
const double pi = 3.1415926535897932384626;

struct cp {
    double x, y;
    cp(double tx = 0.0, double ty = 0.0) {
        this->x = tx;
        this->y = ty;
    }
    inline cp operator +(const cp &d) const {
        return cp(x + d.x, y + d.y);
    }
    inline cp operator -(const cp &d) const {
        return cp(x - d.x, y - d.y);
    }
    inline cp operator *(const cp &d) const { // 复数的乘法直接代数展开就能得到公式 
        return cp(x * d.x - y * d.y, x * d.y + y * d.x);
    }
}A[N << 2], B[N << 2]; // 空间开单个多项式的4倍

int r[N << 2], n, lm;

inline void init() {
    while((1 << lm) < n) {
        lm++;
    }
    n = 1 << lm;
    for(int i = 1; i < n; i++) { // 这里从 0 或 1 开始,到 n 或 n - 1 都行 
        r[i] = (r[i >> 1] >> 1) | ((i & 1) << (lm - 1)); // 背诵! 
    }
    return;
}

inline void FFT(int n, cp *a, int f) {
    for(int i = 0; i < n; i++) {
        if(i < r[i]) {
            std::swap(a[i], a[r[i]]); // 先转换 
        }
    }
    for(int len = 1; len < n; len = len << 1) { // len 是倍增的 
        cp Wn(cos(pi / len), f * sin(pi / len)); // 背诵!
        for(int i = 0; i < n; i += (len << 1)) { // 加的是 (len << 1) !
            cp w(1, 0);                          // 这里三个 < 没有 <= 
            for(int j = 0; j < len; j++) {
                cp t = a[i + len + j] * w;
                a[i + len + j] = a[i + j] - t; /// error : t -> w
                a[i + j] = a[i + j] + t;
                w = w * Wn;
            }
        }
    }
    if(f == -1) {
        for(int i = 0; i <= n; i++) {
            a[i].x /= n; // 除n 
        }
    }
    return;
}

int main() {
    int n1, n2;
    scanf("%d%d", &n1, &n2);
    for(int i = 0; i <= n1; i++) {
        scanf("%lf", &A[i].x);
    }
    for(int i = 0; i <= n2; i++) {
        scanf("%lf", &B[i].x);
    }

    n = n1 + n2 + 1;
    init();

    FFT(n, A, 1);
    FFT(n, B, 1);
    for(int i = 0; i <= n; i++) {
        A[i] = A[i] * B[i];
    }
    FFT(n, A, -1);

    for(int i = 0; i <= n1 + n2; i++) {
        printf("%d ", (int)(A[i].x + 0.5));
    }

    return 0;
}

FFT传参1是把系数式转为点式，-1是逆运算。

用以解决多项式相乘，卷积等。

 2.NTT

快速数论变换，number theory transformation

大概就是把w改成了g，在%%%意义下进行FFT。

与FFT的主要区别在于Wn那里，以及各种取模逆元。

模板在下面一起上。

3.多项式求逆元

反正就是一个极其毒瘤的东西...多项式不仅有逆元还有ln，exp，开根...

如何求逆元?

首先在n = 1的时候逆元是常数项的逆元。

之后用倍增，列方程：

B(x) - B'(x) = 0 

平方同乘A(x)，解方程：

B(x) = 2 * B'(x) - A(x) * B'²(x)

转换为点值相乘：

B[i] = B'[i] * (2 - A[i] * B'[i]);

然后就可以递归求解了。

下面这个是 NTT + 求逆 的模板。

#include <cstdio>
#include <algorithm>
#include <cstring>
typedef long long LL;
const int N = 1000010;
const LL MO = 998244353, g = 3;

int r[N << 2];
LL A[N << 2], B[N << 2], C[N << 2];

inline LL qpow(LL a, LL b) {
    a %= MO;
    LL ans = 1;
    while(b) {
        if(b & 1) {
            ans = ans * a % MO;
        }
        a = a * a % MO;
        b = b >> 1;
    }
    return ans;
}

inline void NTT(int np, LL *a, int f) {
    int n = 1;
    while(n < np) {
        n = n << 1;
    }
    for(int i = 0; i < n; i++) {
        if(i < r[i]) {
            std::swap(a[i], a[r[i]]);
        }
    }

    for(int len = 1; len < n; len = len << 1) {
        LL Wn = qpow(g, (MO - 1) / (len << 1)); // 注意这两行! 
        if(f == -1) {
            Wn = qpow(Wn, MO - 2); // 注意这两行! 
        }
        for(int i = 0; i < n; i += (len << 1)) {
            LL w = 1;
            for(int j = 0; j < len; j++) {
                LL t = a[i + len + j] * w % MO;
                a[i + len + j] = (a[i + j] - t + MO) % MO;
                a[i + j] = (a[i + j] + t) % MO;
                w = w * Wn % MO;
            }
        }
    }

    if(f == -1) {
        LL inv = qpow(n, MO - 2);
        for(int i = 0; i <= np; i++) {
            a[i] = a[i] * inv % MO;
        }
    }
    return;
}

void getinv(LL *A, LL *B, int len) {
    if(len == 1) {
        B[0] = qpow(A[0], MO - 2);
        return;
    }
    getinv(A, B, (len + 1) >> 1); // len 要加 1 
    int n = 1, lm = 0;
    while(n < (len << 1)) {
        n = n << 1;
        lm++;
    }
    for(int i = 1; i < n; i++) {
        r[i] = (r[i >> 1] >> 1) | ((i & 1) << (lm - 1));
    }

    memcpy(C, A, len * sizeof(LL));
    memset(C + len, 0, (n - len) * sizeof(LL)); // 两种写法 
    /*for(int i = 0; i < len; i++) {
        C[i] = A[i];
    }
    for(int i = len; i < n; i++) {
        C[i] = 0;
    }*/

    NTT(n, C, 1);
    NTT(n, B, 1); // 这里对B的两次NTT最好不要去掉，目测会WA 
    for(int i = 0; i < n; i++) {
        B[i] = (2 - C[i] * B[i] % MO) * B[i] % MO;
        if(B[i] < 0) {
            B[i] += MO;
        }
    }
    NTT(n, B, -1);
    for(int i = len; i < n; i++) {
        B[i] = 0; // 别忘了赋0 
    }
    return;
}

int main() {
    int n;
    scanf("%d", &n);
    for(int i = 0; i < n; i++) {
        scanf("%lld", &A[i]);
    }
    getinv(A, B, n);
    for(int i = 0; i < n; i++) {
        printf("%lld ", B[i]);
    }

    return 0;
}

4.多项式除法 & 取模

利用多项式求逆实现。

说多了都是泪啊...先贴个初级模板上来。

#include <cstdio>
#include <algorithm>
#include <cstring>
typedef long long LL;
const int N = 100010;
const LL MO = 998244353, g = 3;

int r[N << 2];
LL a[N << 2], b[N << 2], C[N << 2], invB[N << 2], f[N << 2], q[N << 2];

inline LL qpow(LL a, LL b) {
    LL ans = 1;
    a %= MO;
    while(b) {
        if(b & 1) {
            ans = ans * a % MO;
        }
        a = a * a % MO;
        b = b >> 1;
    }
    return ans;
}

inline void NTT(int np, LL *a, int f) {
    int n = 1;
    while(n < np) {
        n = n << 1;
    }
    for(int i = 1; i < np; i++) {
        if(i < r[i]) {
            std::swap(a[i], a[r[i]]);
        }
    }

    for(int len = 1; len < n; len = len << 1) {
        LL Wn = qpow(g, (MO - 1) / (len << 1));
        if(f == -1) {
            Wn = qpow(Wn, MO - 2);
        }
        for(int i = 0; i < n; i += (len << 1)) {
            LL w = 1;
            for(int j = 0; j < len; j++) {
                LL t = w * a[i + len + j] % MO;
                a[i + len + j] = (a[i + j] - t + MO) % MO;
                a[i + j] = (a[i + j] + t) % MO;
                w = w * Wn % MO;
            }
        }
    }

    if(f == -1) {
        LL inv = qpow(n, MO - 2);
        for(int i = 0; i <= n; i++) {
            a[i] = a[i] * inv % MO;
        }
    }
    return;
}

void getinv(LL *A, LL *B, int len) {
    if(len == 1) {
        B[0] = qpow(A[0], MO - 2);
        return;
    }
    getinv(A, B, (len + 1) >> 1);

    int n = 1, lm = 0;
    while(n < (len << 1)) {
        n = n << 1;
        lm++;
    }
    for(int i = 1; i < n; i++) {
        r[i] = (r[i >> 1] >> 1) | ((i & 1) << (lm - 1));
    }

    memcpy(C, A, len * sizeof(LL));
    memset(C + len, 0, (n - len) * sizeof(LL));
    NTT(n, C, 1);
    NTT(n, B, 1);
    for(int i = 0; i < n; i++) {
        B[i] = (2 - C[i] * B[i] % MO) * B[i] % MO;
        if(B[i] < 0) {
            B[i] += MO;
        }
    }
    NTT(n, B, -1);
    for(int i = len; i < n; i++) {
        B[i] = 0;
    }

    return;
}

inline void div(LL *A, LL *B, LL *F, LL *R, int np, int m) {
    std::reverse(A, A + np + 1);
    std::reverse(B, B + m + 1);
    getinv(B, invB, np - m + 1);

    int len = np - m;
    int n = 1, lm = 0;
    while(n < (len << 1)) {
        n = n << 1;
        lm++;
    }
    for(int i = 1; i < n; i++) {
        r[i] = (r[i >> 1] >> 1) | ((i & 1) << (lm - 1));
    }

    for(int i = 0; i <= len; i++) {
        C[i] = A[i];
    }
    for(int i = len + 1; i < n; i++) {
        C[i] = 0;
        invB[i] = 0;
    }
    NTT(n, C, 1);
    NTT(n, invB, 1);
    for(int i = 0; i < n; i++) {
        F[i] = C[i] * invB[i] % MO;
    }
    NTT(n, F, -1);
    std::reverse(F, F + len + 1);
    for(int i = len + 1; i < n; i++) {
        F[i] = 0;
    }

    // get F

    std::reverse(A, A + np + 1);
    std::reverse(B, B + m + 1);
    n = 1, lm = 0;
    while(n <= np) {
        n = n << 1;
        lm++;
    }
    for(int i = 1; i < n; i++) {
        r[i] = (r[i >> 1] >> 1) | ((i & 1) << (lm - 1));
    }
    for(int i = 0; i <= np; i++) {
        C[i] = F[i];
    }
    for(int i = np + 1; i < n; i++) {
        C[i] = 0;
    }
    for(int i = m + 1; i < n; i++) {
        B[i] = 0;
    }
    NTT(n, B, 1);
    NTT(n, C, 1);
    for(int i = 0; i < n; i++) {
        C[i] = C[i] * B[i] % MO;
    }
    NTT(n, C, -1);
    for(int i = 0; i < m; i++) {
        R[i] = (A[i] - C[i] + MO) % MO;
    }

    return;
}

int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    for(int i = 0; i <= n; i++) {
        scanf("%lld", &a[i]);
    }
    for(int i = 0; i <= m; i++) {
        scanf("%lld", &b[i]);
    }
    div(a, b, f, q, n, m);
    for(int i = 0; i <= n - m; i++) {
        printf("%lld ", f[i]);
    }
    puts("");
    for(int i = 0; i < m; i++) {
        printf("%lld ", q[i]);
    }


    return 0;
}