FFT

多项式乘法可以用 \(O(n^{2})\) 逐项得到，但不高效。而 FFT 可以 \(O(nlogn)\) 快速计算。

第一步是系数 \(\rightarrow\) 点值，分别求得 \(A,B\) 两个多项式在 \(n\) 个 \(n\) 次单位根的取值，并将两个多项式在同一个根的取值相乘，作为两个多项式相乘后得到的多项式在 \(n\) 个 \(n\) 次单位根的取值；
第二步是点值 \(\rightarrow\) 系数，在已知待求多项式的 \(n\) 个点坐标的情况下，求多项式的 \(n\) 个未知系数，即傅里叶逆变换 (IDFT)。

FFT 的两种实现方式：

递归
迭代倍增

模板

// 适合在没有取模要求，且答案较大的情况使用
#include <complex>
const double PI = acos(-1.0);

// 迭代 FFT，a 为复数向量，inverse 表示是否逆变换
void FFT(vector<complex<double>>& a, bool inverse) {
    int n = a.size();
    // 位逆序置换
    for (int i = 1, j = 0; i < n; i++) {
        int bit = n >> 1;
        for (; j & bit; bit >>= 1) j ^= bit;
        j ^= bit;
        if (i < j) swap(a[i], a[j]);
    }
    // 迭代合并
    for (int len = 2; len <= n; len <<= 1) {
        double ang = 2.0 * PI / len * (inverse ? -1.0 : 1.0);
        complex<double> wlen(cos(ang), sin(ang));
        for (int i = 0; i < n; i += len) {
            complex<double> w(1.0, 0.0);
            for (int j = 0; j < len / 2; j++) {
                complex<double> u = a[i + j];
                complex<double> v = a[i + j + len / 2] * w;
                a[i + j] = u + v;
                a[i + j + len / 2] = u - v;
                w *= wlen;
            }
        }
    }
    if (inverse) {
        for (int i = 0; i < n; i++) a[i] /= n;
    }
}

// 多项式乘法（FFT 版本，返回整数系数，四舍五入）
vector<int> Poly_mul(const vector<int>& a, const vector<int>& b) {
    if (a.empty()) return b;
    if (b.empty()) return a;
    // 小规模暴力乘法（结果不会溢出 int）
    if ((ll)a.size() * b.size() <= 5000) {
        vector<int> c(a.size() + b.size() - 1, 0);
        for (size_t i = 0; i < a.size(); i++) {
            for (size_t j = 0; j < b.size(); j++) {
                c[i + j] += (ll)a[i] * b[j];
            }
        }
        return c;
    }
    int need = (int)a.size() + (int)b.size() - 1;
    int n = 1;
    while (n < need) n <<= 1;
    vector<complex<double>> fa(n, 0.0), fb(n, 0.0);
    for (size_t i = 0; i < a.size(); i++) fa[i] = a[i];
    for (size_t i = 0; i < b.size(); i++) fb[i] = b[i];

    FFT(fa, false);
    FFT(fb, false);
    for (int i = 0; i < n; i++) fa[i] *= fb[i];
    FFT(fa, true);

    vector<int> res(need);
    for (int i = 0; i < need; i++) {
        // 四舍五入，处理可能的负零
        double val = fa[i].real();
        res[i] = (int)llround(val);
    }
    return res;
}