「v4」0x30 数学

    「v4」0x30 数学

    同步于 2026-11-11,花费 14,451,581 tok。

    0x31 数学 多项式

    拉格朗日插值

    多项式的插值:给出 n+1n + 1 个点 (x1,y1),(x2,y2),…,(xn+1,yn+1)(x_1, y_1), (x_2, y_2), \dots, (x_{n + 1}, y_{n + 1}),其中横坐标(模意义下)两两不同。求一个至多 nn 次的多项式,使得这 n+1n + 1 个点都在 f(x)f(x) 上。

    拉格朗日插值:

    f(x)=∑i=1n+1yi∏j≠ix−xjxi−xjf(x) = \sum\limits_{i = 1}^{n + 1} y_i \prod\limits_{j \neq i} \frac{x - x_j}{x_i - x_j}

    可以发现 f(x)f(x) 是一个至多 nn 次的多项式,并且可以证明拉格朗日插值是唯一的插值多项式。

    朴素实现的时间复杂度为 O(n2)\mathcal{O}(n^2),可以使用多项式优化到 O(nlog⁡2n)\mathcal{O}(n \log^2 n)(详见多项式快速插值)。

    0x31 拉格朗日插值.cpp:

    // 拉格朗日插值
    int lagrange(std::vector<std::pair<int, int>> seq, int k) {
        int n = seq.size(); // seq 下标从 0 开始,至多 n-1 次多项式需要 n 个点值
        int ans = 0;
        for (int i = 0; i < n; i ++) {
            int p = 1, q = 1;
            for (int j = 0; j < n; j ++) {
                if (i == j) continue;
                mul(p, k - seq[j].first);
                mul(q, seq[i].first - seq[j].first);
            }
            ans = (ans + 1ll * p * qpow(q, mod - 2, mod) % mod * seq[i].second) % mod;
        }
        return norm(ans);
    }

    拉格朗日插值求系数:相当于是直接将整个多项式求出来。运用了暴力除以一次式的技巧。

    • 记系数部分 ai=yi∏j≠i(xi−xj)a_i = \frac{y_i}{\prod_{j \neq i} (x_i - x_j)}。
    • 记多项式 g(x)=∏j(x−xj)g(x) = \prod_{j} (x - x_j),记多项式 hi(x)=∏j≠i(x−xj)h_i(x) = \prod_{j \neq i} (x - x_j)。
    • 先 O(n2)\mathcal{O}(n^2) 暴力多项式乘法求出 g(x)g(x)。考虑由 g(x)g(x) 得到 hi(x)h_i(x),相当于是多项式 g(x)g(x) 除以一次式 (x−xi)(x - x_i),可以 O(n)\mathcal{O}(n) 暴力除以一次式。
    • 具体地,由于 (x−xi)hi(x)=g(x)(x - x_i)h_i(x) = g(x),则对于 g(x)g(x) 的 jj (j≥1j \geq 1) 次项系数,有 [xj−1]hi−xi[xj]hi=[xj]g[x^{j - 1}]h_i - x_i[x^j]h_i = [x^j]g。于是
      [xn]hi=[xn+1]g[xj]hi=[xj+1]g+xi[xj+1]hi\begin{gathered} [x^n]h_i = [x^{n + 1}]g \\ [x^j]h_i = [x^{j + 1}]g + x_i[x^{j + 1}]h_i \\ \end{gathered}
      从后往前递推即可求出 hi(x)h_i(x)。
    • 求出了 aia_i 与 hi(x)h_i(x) 之后,计算 f(x)=∑i=1n+1aihi(x)f(x) = \sum_{i = 1}^{n + 1}a_ih_i(x)。时间复杂度 O(n2)\mathcal{O}(n^2)。

    0x31 拉格朗日插值求系数.cpp:

    // 拉格朗日插值求系数
    std::vector<int> lagrange(std::vector<std::pair<int, int>> seq) {
        int n = seq.size(); // seq 下标从 0 开始,至多 n-1 次多项式需要 n 个点值
    
        std::vector<int> a(n); // 系数部分 a[]
        for (int i = 0; i < n; i ++) {
            int q = 1;
            for (int j = 0; j < n; j ++) {
                if (i == j) continue;
                mul(q, seq[i].first - seq[j].first);
            }
            a[i] = 1ll * seq[i].second * qpow(q, mod - 2, mod) % mod;
        }
    
        std::vector<int> g(n + 1); // 总多项式 g
        g[0] = 1;
        for (int i = 0; i < n; i ++) {
            for (int j = i + 1; j >= 1; j --) {
                g[j] = (1ll * g[j] * -seq[i].first + g[j - 1]) % mod;
            }
            g[0] = 1ll * g[0] * -seq[i].first % mod;
        }
        
        std::vector<int> f(n); // 答案多项式 f
        for (int i = 0; i < n; i ++) {
            std::vector<int> h(n); // 分多项式 h_i
            h[n - 1] = g[n];
            for (int j = n - 2; j >= 0; j --) {
                h[j] = (g[j + 1] + 1ll * h[j + 1] * seq[i].first) % mod;
            }
    
            for (int j = 0; j < n; j ++) {
                f[j] = (f[j] + 1ll * a[i] * h[j]) % mod;
            }
        }
    
        for (int &x : f) x = norm(x);
        return f;
    }
    
    int func(const std::vector<int> &f, int k) {
        int n = f.size();
        int y = 0;
        for (int i = n - 1; i >= 0; i --) {
            y = (1ll * y * k + f[i]) % mod;
        }
        return norm(y);
    }

    连续点值的拉格朗日插值:给出 n+1n + 1 个连续点值 f(1),f(2),…,f(n+1)f(1), f(2), \dots, f(n + 1),代入拉格朗日插值公式,得

    f(x)=∑i=1n+1yi∏j≠ix−ji−jf(x) = \sum\limits_{i = 1}^{n + 1}y_i \prod\limits_{j \neq i}\frac{x - j}{i - j}

    现在考虑给定一个自变量 xx,求出因变量 f(x)f(x)。考虑右边的乘积项怎么求

    • 分子:记 prei=∏1≤j≤i(x−j)\mathrm{pre}_i = \prod_{1 \leq j \leq i} (x - j),sufi=∏i≤j≤n+1(x−j)\mathrm{suf}_i = \prod_{i \leq j \leq n + 1} (x - j),则分子为 prei−1×sufi+1\mathrm{pre}_{i - 1} \times \mathrm{suf}_{i + 1}。
    • 分母:j<ij < i 的部分是 i−1i - 1 到 11 乘起来。j>ij > i 的部分是 −1-1 到 −(n+1−i)-(n + 1 - i) 乘起来。故分母为 (i−1)!(n+1−i)!(−1)n+1−i(i - 1)! (n + 1 - i)! (-1)^{n + 1 - i}。

    故最后的式子为

    f(x)=∑i=1n+1yiprei−1×sufi+1(i−1)!(n+1−i)!(−1)n+1−if(x) = \sum\limits_{i = 1}^{n + 1}y_i \frac{\mathrm{pre}_{i - 1} \times \mathrm{suf}_{i + 1}}{(i - 1)!(n + 1 - i)!(-1)^{n + 1 - i}}

    求出单个点值的时间复杂度为 O(n)\mathcal{O}(n)。

    若给出 n+1n + 1 个连续点值 f(h),f(h+1),…,f(h+n)f(h), f(h + 1), \dots, f(h + n),分母的求法是完全不变的,只需将分子改成 x−xjx - x_j 相乘即可。

    或者可以考虑将坐标系向左平移 h−1h - 1。

    0x31 连续点值的拉格朗日插值.cpp:

    // 连续点值的拉格朗日插值
    int lagrange(std::vector<int> y, int k) {
        int n = y.size() - 1; // y 下标从 1 开始,连续点值为 f(1), ..., f(n)
        if (k >= 1 && k <= n) {
            return y[k];
        }
    
        std::vector<int> pre(n + 2), suf(n + 2);
        pre[0] = 1;
        for (int i = 1; i <= n; i ++) {
            pre[i] = 1ll * pre[i - 1] * (k - i) % mod;
        }
        suf[n + 1] = 1;
        for (int i = n; i >= 1; i --) {
            suf[i] = 1ll * suf[i + 1] * (k - i) % mod;
        }
    
        std::vector<int> fact(n + 1), facv(n + 1);
        fact[0] = 1;
        for (int i = 1; i <= n; i ++) {
            fact[i] = 1ll * fact[i - 1] * i % mod;
        }
        facv[n] = qpow(fact[n], mod - 2, mod);
        for (int i = n - 1; i >= 0; i --) {
            facv[i] = 1ll * facv[i + 1] * (i + 1) % mod;
        }
    
        int ans = 0;
        for (int i = 1; i <= n; i ++) {
            int cur = y[i];
            cur = 1ll * cur * pre[i - 1] % mod * suf[i + 1] % mod;
            cur = 1ll * cur * facv[i - 1] % mod * facv[n - i] % mod;
            if ((n - i) & 1) cur = -cur;
            add(ans, norm(cur));
        }
    
        return ans;
    }

    FFT

    单位根:nn 次单位根,即为 xn=1x^n = 1 的所有复数解。共 nn 个,依次表示为 ωn0,ωn1,ωn2,…,ωnn−1\omega_n^0, \omega_n^1, \omega_n^2, \dots, \omega_n^{n - 1},在单位圆上的辐角分别为 0,2πn,4πn,…,2(n−1)πn0, \frac{2\pi}{n}, \frac{4\pi}{n}, \dots, \frac{2(n - 1)\pi}{n}。由欧拉公式 ωn1=e2πin=cos⁡(2πn)+isin⁡(2πn)\omega_n^1 = e^{\frac{2\pi i}{n}} = \cos(\frac{2\pi}{n}) + i \sin(\frac{2\pi}{n})。

    单位根的简单性质:

    • ωni×ωnj=ωni+j\omega_n^i \times \omega_n^j = \omega_n^{i + j},(ωni)j=ωnij\left(\omega_n^i\right)^j = \omega_n^{ij}。
    • ω2n2k=ωnk\omega_{2n}^{2k} = \omega_n^k
    • ω2nk=−ω2nk+n\omega_{2n}^k = -\omega_{2n}^{k + n}

    补充界:在进行 FFT 之前,需要对其最高位补 00,将其补成一个最高次数为 2P−12^P - 1 的多项式。方便后续的奇偶性分组。

    DFT:DFT 的思想:“系数表示法”转“点值表示法”。

    已知系数 a0,…,an−1a_0, \dots, a_{n - 1},计算点值 F(ωn0),F(ωn1),…,F(ωnn−1)F(\omega_n^0), F(\omega_n^1), \dots, F(\omega_n^{n - 1})。

    记 n=2Pn = 2^P,考虑一个 2P−12^P - 1 次的多项式 F(x)F(x)。将每一项按照次数的奇偶性,划分成两部分。记 FL(x)=a0+a2x+⋯+an−2xn/2−1F_L(x) = a_0 + a_2x + \dots + a_{n - 2}x^{n / 2 - 1},FR(x)=a1+a3x+⋯+an−1xn/2−1F_R(x) = a_1 + a_3x + \dots + a_{n - 1}x^{n / 2 - 1},则

    F(x)=FL(x2)+xFR(x2)F(x) = F_L(x^2) + xF_R(x^2)

    对于 k<n/2k < n / 2,将 ωnk\omega_n^k 与 ωnk+n/2\omega_n^{k + n / 2} 代入上式,由单位根的性质可得 F(ωnk),F(ωnk+n/2)F(\omega_n^k), F(\omega_n^{k + n / 2}) 等于 FL(ωn/2k)±ωnkFR(ωn/2k)F_L(\omega_{n / 2}^k)\pm\omega_n^kF_R(\omega_{n / 2}^k)。

    因此由 FL(x),FR(x)F_L(x), F_R(x) 在 ωn/20,…,ωn/2n/2−1\omega_{n / 2}^0, \dots, \omega_{n / 2}^{n / 2 - 1} 处的点值,可以 O(n)\mathcal{O}(n) 推出 F(x)F(x) 在 ωn0,…,ωnn−1\omega_n^0, \dots, \omega_n^{n - 1} 处的点值。

    这是一个分治的过程,不断分治直到剩下一个项即可。时间复杂度 O(nlog⁡n)\mathcal{O}(n \log n)。

    IDFT:IDFT 的思想:“点值表示法”转“系数表示法”。

    已知点值 F(ωn0),F(ωn1),…,F(ωnn−1)F(\omega_n^0), F(\omega_n^1), \dots, F(\omega_n^{n - 1}),求出系数 a0,…,an−1a_0, \dots, a_{n - 1}。

    结论:将 DFT 中的 ωn1\omega_n^1 换成 ωn−1\omega_n^{-1},做完以后除以 nn 即可。

    由单位根反演的经典结论 [n∣k]=1n∑i=0n−1ωnik[n \mid k] = \frac{1}{n}\sum_{i = 0}^{n - 1}\omega_{n}^{ik},可以证明:

    gk=∑i=0n−1ai(ωnk)i  ⟺  ak=1n∑i=0n−1gi(ωn−k)ig_k = \sum\limits_{i = 0}^{n - 1}a_i \left( \omega_n^k \right)^i \iff a_k = \frac{1}{n} \sum\limits_{i = 0}^{n - 1}g_i \left( \omega_n^{-k} \right)^i

    再进一步,发现 F(ωn−i)=F(ωnn−i)F(\omega_n^{-i}) = F(\omega_n^{n - i}),于是 IDFT 可以看作将 DFT 后得到的点值进行翻转(注意 F(ωn0)F(\omega_n^0) 这一项不参与翻转),然后再除以 nn。套用 DFT 的板子即可。

    位逆序置换(FFT 倍增实现):

    以 n=8n = 8 为例,模拟分治的过程:

    {a0,a1,a2,a3,a4,a5,a6,a7}{a0,a2,a4,a6}{a1,a3,a5,a7}{a0,a4}{a2,a6}{a1,a5}{a3,a7}{a0}{a4}{a2}{a6}{a1}{a5}{a3}{a7}\begin{gathered} \{ a_0, a_1, a_2, a_3, a_4, a_5, a_6, a_7 \} \\ \{ a_0, a_2, a_4, a_6 \}\{ a_1, a_3, a_5, a_7 \} \\ \{ a_0, a_4 \} \{ a_2, a_6 \} \{ a_1, a_5 \} \{ a_3, a_7 \} \\ \{ a_0 \} \{ a_4 \} \{ a_2 \} \{ a_6 \} \{ a_1 \} \{ a_5 \} \{ a_3 \} \{ a_7 \} \end{gathered}

    分治自顶向下,每层按照下标奇偶性划分;倍增则自底向上,因此需要预先确定每个 aia_i 在最底层的位置。

    将 ii 用二进制数表示,则 aia_i 在最底层的位置即为该二进制数的翻转(例如 011000 变成 000110)。证明:每次根据奇偶性将 aia_i 进行分类,相当于是由最低位决定最高位。以此类推,次低位决定次高位,第三低位决定第三高位 …

    蝶形运算(FFT 倍增实现):

    自底向上合并,对于当前长度为 nn 的块,已知左右两块分别存放 FL,FRF_L, F_R 的 n/2n / 2 个点值。

    • 更新前:FL(ωn/2k)F_L(\omega_{n / 2}^k) 储存在数组下标为 kk 的位置,FR(ωn/2k)F_R(\omega_{n / 2}^k) 储存在数组下标为 k+n/2k + n / 2 的位置。
    • 更新后:F(ωnk)F(\omega_n^k) 储存在数组下标为 kk 的位置,F(ωnk+n/2)F(\omega_n^{k + n / 2}) 储存在数组下标为 k+n/2k + n / 2 的位置。

    因此可以直接在数组下标为 kk 和 k+n/2k + n / 2 的位置进行覆写,而不用开额外的辅助数组。

    FFT 多项式乘法:

    对于两个多项式 A,BA, B,现在要求出多项式 C=A×BC = A \times B。

    考虑对 A,BA, B 进行 DFT,经过 DFT 之后得到一系列关于 A,BA, B 的点值,将关于 A,BA, B 的点值对应位置相乘即可得到 CC 的点值,再对 CC 的点值进行 IDFT 即可得到 CC 的系数。

    时间复杂度 O((n+m)log⁡(n+m))\mathcal{O}((n + m) \log (n + m))。

    循环卷积:对长度为 LL 的两个序列进行 DFT,将点值对应位置相乘,再 IDFT 回去。实际上是做长度为 LL 的循环卷积,即 aibja_ib_j 贡献给了 c(i+j) mod Lc_{(i + j) \bmod L}。当补充界 L≥n+m+1L \geq n + m + 1 时,即为正常卷积。只需要部分项时,可以据此缩小补充界(见半在线卷积的卡常技巧)。

    0x31 FFT.cpp:

    const double pi = acos(-1);
    using comp = std::complex<double>;
    
    std::vector<comp> roots{0, 1};
    void dft(std::vector<comp> &a) {
        int n = a.size();
        for (int i = 1, j = 0; i < n; i ++) {
            for (int k = n >> 1; (j ^= k) < k; k >>= 1);
            if (i < j) std::swap(a[i], a[j]);
        }
        for (int k = roots.size(); k < n; k <<= 1) {
            comp w(cos(pi / k), sin(pi / k));
            roots.resize(k << 1);
            for (int i = k >> 1; i < k; i ++) {
                roots[i * 2] = roots[i];
                roots[i * 2 + 1] = roots[i] * w;
            }
        }
        for (int k = 1; k < n; k <<= 1) {
            for (int i = 0; i < n; i += (k << 1)) {
                for (int j = 0; j < k; j ++) {
                    comp u = a[i + j], v = a[i + j + k] * roots[k + j];
                    a[i + j] = u + v, a[i + j + k] = u - v;
                }
            }
        }
    }
    void idft(std::vector<comp> &a) {
        int n = a.size();
        std::reverse(a.begin() + 1, a.end());
        dft(a);
        for (int i = 0; i < n; i ++) {
            a[i] /= n;
        }
    }
    
    struct poly : public std::vector<comp> {
        using std::vector<comp>::vector;
        explicit poly(const std::vector<comp> &a) : std::vector<comp>(a) {}
    
        friend poly operator * (poly a, poly b) {
            int tot = a.size() + b.size() - 1;
            if (tot < 128) {
                poly c(tot);
                for (int i = 0; i < a.size(); i ++) {
                    for (int j = 0; j < b.size(); j ++) {
                        c[i + j] += a[i] * b[j];
                    }
                }
                return c;
            }
            int L = 1;
            while (L < tot) L <<= 1;
            a.resize(L), b.resize(L);
            dft(a), dft(b);
            for (int i = 0; i < L; i ++) {
                a[i] *= b[i];
            }
            idft(a);
            a.resize(tot);
            return a;
        }
    };

    NTT

    在模意义下,我们希望找到一个东西来代替单位根。主要是要满足 FFT 过程中,用到的单位根的三个性质:

    • ωn\omega_n 的阶为 nn。
    • ω2n2k=ωnk\omega_{2n}^{2k} = \omega_n^k。
    • ω2nk=−ω2nn+k\omega_{2n}^k = -\omega_{2n}^{n + k}。

    对于一个质数 mm,考虑 mm 的一个原根 gg。此时 gg 的阶为 m−1m - 1,显然原根 gg 不能直接代替 nn 阶单位根。

    考虑 gg 的若干次幂。gkg^k 的阶为 m−1gcd⁡(m−1,k)\frac{m - 1}{\gcd(m - 1, k)}。于是当 n∣(m−1)n \mid (m - 1) 时,可以构造 gm−1ng^{\frac{m - 1}{n}} 的阶恰好等于 nn。尝试使用 gm−1ng^{\frac{m - 1}{n}} 代替 nn 阶单位根:

    • 性质 1, 2 的证明显然。
    • 性质 3 相当于是要证明 gm−12≡−1(modm)g^{\frac{m - 1}{2}} \equiv -1 \pmod m,可以使用二次剩余中的欧拉判别法来证明(原根必定不是二次剩余)。

    于是当 n∣(m−1)n \mid (m - 1) 时,我们完全可以使用 gm−1ng^{\frac{m - 1}{n}} 来代替 nn 阶单位根 ωn\omega_n。

    现在还要满足 n∣(m−1)n \mid (m - 1) 才可以代替,对模数 mm 的取值有特殊的要求。注意到 FFT 过程中的 nn 都是 22 的若干次幂,所以 m−1m - 1 只需要包含大量的因子 22 即可。

    例如 998244353=223×7×17+1998244353 = 2^{23} \times 7 \times 17 + 1,就是一个经典的 NTT 模数。

    常用的 NTT 模数:

    • 998244353:原根为 33。
    • 1004535809:原根为 33。
    • 469762049:原根为 33。
    • 167772161:原根为 33。
    • 924844033:原根为 55。
    • 4179340454199820289(4×10184 \times 10^{18} 级别,以时间换精度):原根为 33。

    0x31 NTT.cpp:

    std::vector<int> roots{0, 1};
    void dft(std::vector<int> &a) {
        int n = a.size();
        for (int i = 1, j = 0; i < n; i ++) {
            for (int k = n >> 1; (j ^= k) < k; k >>= 1);
            if (i < j) std::swap(a[i], a[j]);
        }
        for (int k = roots.size(); k < n; k <<= 1) {
            int w = qpow(3, (mod - 1) / (k << 1), mod); // 原根根据实际模数调整
            roots.resize(k << 1);
            for (int i = k >> 1; i < k; i ++) {
                roots[i * 2] = roots[i];
                roots[i * 2 + 1] = 1ll * roots[i] * w % mod;
            }
        }
        for (int k = 1; k < n; k <<= 1) {
            for (int i = 0; i < n; i += (k << 1)) {
                for (int j = 0; j < k; j ++) {
                    int u = a[i + j], v = 1ll * a[i + j + k] * roots[k + j] % mod;
                    add(a[i + j] = u, v), dec(a[i + j + k] = u, v);
                }
            }
        }
    }
    void idft(std::vector<int> &a) {
        int n = a.size(), inv = (1 - mod) / n + mod;
        std::reverse(a.begin() + 1, a.end());
        dft(a);
        for (int i = 0; i < n; i ++) {
            mul(a[i], inv);
        }
    }
    
    struct poly : public std::vector<int> {
        using std::vector<int>::vector;
        explicit poly(const std::vector<int> &a) : std::vector<int>(a) {}
    
        friend poly operator * (poly a, poly b) {
            int tot = a.size() + b.size() - 1;
            if (tot < 128) {
                poly c(tot);
                for (int i = 0; i < a.size(); i ++) {
                    for (int j = 0; j < b.size(); j ++) {
                        c[i + j] = (c[i + j] + 1ll * a[i] * b[j]) % mod;
                    }
                }
                return c;
            }
            int L = 1;
            while (L < tot) L <<= 1;
            a.resize(L), b.resize(L);
            dft(a), dft(b);
            for (int i = 0; i < L; i ++) {
                mul(a[i], b[i]);
            }
            idft(a);
            a.resize(tot);
            return a;
        }
    };

    MTT

    当模数不为常用的 NTT 模数时,我们就需要使用一些技巧使得多项式乘法可以继续进行。

    首先不可以简单地使用 FFT,因为 double 的有效精度只有 15∼1615\sim 16 位十进制有效数字,而对于常见的数据范围 n,m≤105n, m \leq 10^5 以及 ai,bi≤109a_i, b_i \leq 10^9,卷积结果的最大值接近 105×109×109=102310^5 \times 10^9 \times 10^9 = 10^{23},一定会掉精度。

    三模 NTT

    选择三个 10910^9 级别的常用 NTT 模数,用三个模数分别做一次 NTT,将得到的三个结果使用 CRT 合并。

    常用的 NTT 模数选法如下,因为这三个 NTT 模数均有一个原根为 33。

    mod1=998244353mod2=1004535809mod3=469762049\begin{aligned} & \mathrm{mod}1 = 998244353 \\ & \mathrm{mod}2 = 1004535809 \\ & \mathrm{mod}3 = 469762049 \end{aligned}

    该做法的优点是,可以通过 CRT 精确得到未经取模的卷积结果,对值域的范围要求比较友好。

    0x31 MTT(三模 NTT).cpp:

    template <const int mod>
    struct ntt {
        inline void add(int &x, const int &y) { x += y; if (x >= mod) x -= mod; }
        inline void dec(int &x, const int &y) { x -= y; if (x < 0) x += mod; }
        inline void mul(int &x, const int &y) { x = 1ll * x * y % mod; }
    
        std::vector<int> roots{0, 1};
        void dft(std::vector<int> &a) {
            int n = a.size();
            for (int i = 1, j = 0; i < n; i ++) {
                for (int k = n >> 1; (j ^= k) < k; k >>= 1);
                if (i < j) std::swap(a[i], a[j]);
            }
            for (int k = roots.size(); k < n; k <<= 1) {
                int w = qpow(3, (mod - 1) / (k << 1), mod);
                roots.resize(k << 1);
                for (int i = k >> 1; i < k; i ++) {
                    roots[i * 2] = roots[i];
                    roots[i * 2 + 1] = 1ll * roots[i] * w % mod;
                }
            }
            for (int k = 1; k < n; k <<= 1) {
                for (int i = 0; i < n; i += (k << 1)) {
                    for (int j = 0; j < k; j ++) {
                        int u = a[i + j], v = 1ll * a[i + j + k] * roots[k + j] % mod;
                        add(a[i + j] = u, v), dec(a[i + j + k] = u, v);
                    }
                }
            }
        }
        void idft(std::vector<int> &a) {
            int n = a.size(), inv = (1 - mod) / n + mod;
            std::reverse(a.begin() + 1, a.end());
            dft(a);
            for (int i = 0; i < n; i ++) {
                mul(a[i], inv);
            }
        }
    
        auto mul(std::vector<int> a, std::vector<int> b) {
            for (int &x : a) x %= mod;
            for (int &x : b) x %= mod;
            dft(a), dft(b);
            for (int i = 0; i < a.size(); i ++) {
                mul(a[i], b[i]);
            }
            idft(a);
            return a;
        }
    };
    
    const int mod1 = 998244353, mod2 = 1004535809, mod3 = 469762049;
    ntt<mod1> ntt1;
    ntt<mod2> ntt2;
    ntt<mod3> ntt3;
    
    int CRT(int x1, int x2, int x3) {
        static const i64 M12 = 1ll * mod1 * mod2;
        static const int
            inv1 = qpow(mod1, mod2 - 2, mod2),
            inv12 = qpow(M12 % mod3, mod3 - 2, mod3);
        int t1 = 1ll * (x2 - x1 + mod2) * inv1 % mod2;
        i64 x12 = x1 + 1ll * mod1 * t1;
        int t2 = (x3 - x12 % mod3 + mod3) * inv12 % mod3;
        return (x12 % mod + (M12 % mod) * t2) % mod;
    }
    
    // int CRT(int x1, int x2, int x3) {
    //     static const i128 M = i128(mod1) * mod2 * mod3;
    //     static const i64 M1 = M / mod1, M2 = M / mod2, M3 = M / mod3;
    //     static const int
    //         V1 = qpow(M1 % mod1, mod1 - 2, mod1),
    //         V2 = qpow(M2 % mod2, mod2 - 2, mod2),
    //         V3 = qpow(M3 % mod3, mod3 - 2, mod3);
    //     i128 x = 0;
    //     x += i128(x1) * M1 * V1;
    //     x += i128(x2) * M2 * V2;
    //     x += i128(x3) * M3 * V3;
    //     x %= M; // 此时的 x 即为 CRT 的解
    //     return x % mod;
    // }
    
    struct poly : public std::vector<int> {
        using std::vector<int>::vector;
        explicit poly(const std::vector<int> &a) : std::vector<int>(a) {}
    
        friend poly operator * (poly a, poly b) {
            int tot = a.size() + b.size() - 1;
            if (tot < 128) {
                poly c(tot);
                for (int i = 0; i < a.size(); i ++) {
                    for (int j = 0; j < b.size(); j ++) {
                        c[i + j] = (c[i + j] + 1ll * a[i] * b[j]) % mod;
                    }
                }
                return c;
            }
            int L = 1;
            while (L < tot) L <<= 1;
            a.resize(L), b.resize(L);
            auto c1 = ntt1.mul(a, b), c2 = ntt2.mul(a, b), c3 = ntt3.mul(a, b);
            poly c(tot);
            for (int i = 0; i < tot; i ++) {
                c[i] = CRT(c1[i], c2[i], c3[i]);
            }
            return c;
        }
    };

    拆系数 FFT

    当 mod<230\mathrm{mod} < 2^{30} 时,将每个系数拆成两个 1515 位的数(x=x0+x1×215x = x_0 + x_1 \times 2^{15}),然后将低位 x0x_0 和高位 x1x_1 分别作为复数的实部和虚部进行 DFT。此时卷积结果就可以被 double 精确表示。

    该做法的优点是,只需要进行 44 次 DFT,效率较高,代码也相对好写。缺点是 nn 较大时,可能会掉精度。

    0x31 MTT(拆系数 FFT).cpp:

    const double pi = acos(-1);
    using comp = std::complex<double>;
    
    std::vector<comp> roots{0, 1};
    void dft(std::vector<comp> &a) {
        int n = a.size();
        for (int i = 1, j = 0; i < n; i ++) {
            for (int k = n >> 1; (j ^= k) < k; k >>= 1);
            if (i < j) std::swap(a[i], a[j]);
        }
        for (int k = roots.size(); k < n; k <<= 1) {
            comp w(cos(pi / k), sin(pi / k));
            roots.resize(k << 1);
            for (int i = k >> 1; i < k; i ++) {
                roots[i * 2] = roots[i];
                roots[i * 2 + 1] = roots[i] * w;
            }
        }
        for (int k = 1; k < n; k <<= 1) {
            for (int i = 0; i < n; i += (k << 1)) {
                for (int j = 0; j < k; j ++) {
                    comp u = a[i + j], v = a[i + j + k] * roots[k + j];
                    a[i + j] = u + v, a[i + j + k] = u - v;
                }
            }
        }
    }
    void idft(std::vector<comp> &a) {
        int n = a.size();
        std::reverse(a.begin() + 1, a.end());
        dft(a);
        for (int i = 0; i < n; i ++) {
            a[i] /= n;
        }
    }
    
    struct poly : public std::vector<int> {
        using std::vector<int>::vector;
        explicit poly(const std::vector<int> &a) : std::vector<int>(a) {}
    
        friend poly operator * (poly a, poly b) {
            int tot = a.size() + b.size() - 1;
            if (tot < 128) {
                poly c(tot);
                for (int i = 0; i < a.size(); i ++) {
                    for (int j = 0; j < b.size(); j ++) {
                        c[i + j] = (c[i + j] + 1ll * a[i] * b[j]) % mod;
                    }
                }
                return c;
            }
            int L = 1;
            while (L < tot) L <<= 1;
            std::vector<comp> P(L), Q(L), R(L), S(L);
            for (int i = 0; i < a.size(); i ++) {
                P[i] = comp(a[i] & 32767, a[i] >> 15);
            }
            for (int i = 0; i < b.size(); i ++) {
                Q[i] = comp(b[i] & 32767, b[i] >> 15);
            }
            dft(P), dft(Q);
            for (int i = 0; i < L; i ++) {
                int j = (L - i) & (L - 1);
                comp a0 = (P[i] + std::conj(P[j])) * 0.5;
                comp a1 = (P[i] - std::conj(P[j])) * comp(0, -0.5);
                R[i] = a0 * Q[i], S[i] = a1 * Q[i];
            }
            idft(R), idft(S);
            poly c(tot);
            for (int i = 0; i < tot; i ++) {
                i64 c0 = llround(R[i].real()) % mod;
                i64 c1 = (llround(R[i].imag()) + llround(S[i].real())) % mod;
                i64 c2 = llround(S[i].imag()) % mod;
                c[i] = ((c2 << 30) + (c1 << 15) + c0) % mod;
            }
            return c;
        }
    };

    Trick:翻转卷积

    给出序列 a0,…,ana_0, \dots, a_n 与序列 b0,…,bmb_0, \dots, b_m,对于每一个 kk 需要求出 ck=∑iaibi−kc_k = \sum_{i} a_ib_{i - k},即下标差恒为 kk 的卷积式(相当于 aibja_ib_j 贡献给了 ci−jc_{i - j})。

    将序列 bb 翻转得到 b′b',其中 bm−j′=bjb'_{m - j} = b_j。对序列 a,b′a, b' 进行普通卷积得到序列 c′c',此时 aibja_ib_j 贡献给了 cm+i−j′c'_{m + i - j},于是有 ck=ck+m′c_k = c'_{k + m}。

    Trick:积卷积

    给出序列 a1,…,ap−1a_1, \dots, a_{p - 1} 与序列 b1,…,bp−1b_1, \dots, b_{p - 1},对于每一个 k∈[1,p)k \in [1, p) 需要求出 ck=∑i⋅j mod p=kaibjc_k = \sum_{i\cdot j \bmod p = k} a_ib_j。

    当模数为较小的质数 pp 时,可以使用“离散对数”,将模 pp 意义下的乘法转换为模 p−1p - 1 意义下的加法。

    Trick:多项式点乘向量

    给出多项式 A(x)=∑i=0naixiA(x) = \sum_{i = 0}^n a_ix^i 与向量 B=(b0,…,bn)\mathbf{B} = (b_0, \dots, b_n),现在我们要求多项式 AA 点乘向量 B\mathbf{B} 的值

    A⋅B=∑i=0naibiA \cdot \mathbf{B} = \sum_{i = 0}^n a_ib_i

    记翻转多项式 BR(x)=∑i=0nbn−ixiB^R(x) = \sum_{i = 0}^n b_{n - i}x^i,则点乘的值即为 [xn](A×BR)[x^n](A \times B^R),即 A×BRA \times B^R 的其中一项。

    e.g. 给出多项式序列 p1,…,pnp_1, \dots, p_n,欲求 (∏i=lrpi)⋅B\left(\prod_{i = l}^r p_i\right) \cdot \mathbf{B},即求 prer×iprel−1×BR\mathrm{pre}_r \times \mathrm{ipre}_{l - 1} \times B^R 的第 nn 项。

    预处理出所有的 prei×BR\mathrm{pre}_i \times B^R 以及 iprei\mathrm{ipre}_i 即可。

    Model:分治卷积

    分治 NTT 模型 1:给出 nn 个数 a1,…,ana_1, \dots, a_n,求出 nn 个一次式的积 ∏i=1n(aix+1)\prod_{i = 1}^n(a_ix + 1)。

    设 f(l,r)f(l, r) 表示区间 [l,r][l, r] 中所有一次式的积,f(l,r)f(l, r) 是一个次数为 r−l+1r - l + 1 的多项式(与区间长度有关)。

    取 mid=⌊l+r2⌋\mathrm{mid} = \lfloor \frac{l + r}{2} \rfloor,则有

    f(l,r)=f(l,mid)×f(mid+1,r)f(l, r) = f(l, \mathrm{mid}) \times f(\mathrm{mid} + 1, r)

    这是一个分治的过程,不断分治直到 l=rl = r 即可。

    时间复杂度 T(n)=2T(n2)+O(nlog⁡n)=O(nlog⁡2n)T(n) = 2T\left( \frac{n}{2} \right) + \mathcal{O}(n \log n) = \mathcal{O}(n \log^2 n)。

    By the way:求出 nn 个多项式的积,次数之和为 mm。

    可以每次取出两个次数最小的多项式相乘后放回,时间复杂度 O(mlog⁡2m)\mathcal{O}(m \log^2 m)。

    其实使用分治求解的时间复杂度也是相同的。

    分治 NTT 模型 2:给出 nn 个数 a1,…,ana_1, \dots, a_n,求出 nn 个一次分式的和 ∑i=1n11−aix\sum_{i = 1}^n \frac{1}{1 - a_ix}。

    对于分式 A1A2,B1B2\frac{A_1}{A_2}, \frac{B_1}{B_2},若我们已知分子 A1,B1A_1, B_1 与分母 A2,B2A_2, B_2,由通分可得 A1A2+B1B2=A1B2+A2B1A2B2\frac{A_1}{A_2} + \frac{B_1}{B_2} = \frac{A_1B_2 + A_2B_1}{A_2B_2},由此可以得到新的分子 A1B2+A2B1A_1B_2 + A_2B_1 与分母 A2B2A_2B_2。

    设 A(l,r),B(l,r)A(l, r), B(l, r) 分别表示区间 [l,r][l, r] 中所有一次分式之和通分后所得的分子与分母。A(l,r),B(l,r)A(l, r), B(l, r) 的次数同样与区间长度有关。

    取 mid=⌊l+r2⌋\mathrm{mid} = \lfloor \frac{l + r}{2} \rfloor,则有

    A(l,r)=A(l,mid)×B(mid+1,r)+A(mid+1,r)×B(l,mid)B(l,r)=B(l,mid)×B(mid+1,r)\begin{gathered} A(l, r) = A(l, \mathrm{mid}) \times B(\mathrm{mid} + 1, r) + A(\mathrm{mid} + 1, r) \times B(l, \mathrm{mid}) \\ B(l, r) = B(l, \mathrm{mid}) \times B(\mathrm{mid} + 1, r) \end{gathered}

    通过分治求出 A(1,n),B(1,n)A(1, n), B(1, n),最后求逆一次即可。

    时间复杂度 O(nlog⁡2n)\mathcal{O}(n \log^2 n)。

    分治 NTT 模型 3:给出 nn 个数 a1,…,ana_1, \dots, a_n,求出 ∑i=1n∏j≠i(ajx+1)\sum_{i = 1}^n \prod_{j \neq i} (a_jx + 1)。

    设 f(l,r)=∑i=lr∏j∈[l,r],j≠i(ajx+1)f(l, r) = \sum_{i = l}^r \prod_{j \in [l, r], j \neq i} (a_jx + 1),g(l,r)=∏i=lr(aix+1)g(l, r) = \prod_{i = l}^r (a_ix + 1),f(l,r),g(l,r)f(l, r), g(l, r) 的次数同样与区间长度有关。

    取 mid=⌊l+r2⌋\mathrm{mid} = \lfloor \frac{l + r}{2} \rfloor,则有

    f(l,r)=f(l,mid)×g(mid+1,r)+f(mid+1,r)×g(l,mid)g(l,r)=g(l,mid)×g(mid+1,r)\begin{gathered} f(l, r) = f(l, \mathrm{mid}) \times g(\mathrm{mid} + 1, r) + f(\mathrm{mid} + 1, r) \times g(l, \mathrm{mid}) \\ g(l, r) = g(l, \mathrm{mid}) \times g(\mathrm{mid} + 1, r) \end{gathered}

    时间复杂度 O(nlog⁡2n)\mathcal{O}(n \log^2 n)。

    分治 NTT 模型 4:若递归到分治树的节点 uu 时,只需要保留多项式中的 O(su)\mathcal{O}(s_u) 个有效项(其余的项可以特殊处理从而无需继续递归),并且节点 uu 上需要进行规模为 O(su)\mathcal{O}(s_u) 的卷积。

    记整棵分治树所有节点的 sus_u 之和等于 mm,则时间复杂度 O(mlog⁡m)\mathcal{O}(m \log m)。

    分治 NTT 模型 5(djq 分治):QQ 次询问组合数前缀和。每次询问给出 n,mn, m,求 ∑i=0m(ni) mod 998244353\sum_{i = 0}^m \binom{n}{i} \bmod 998244353。

    注意到 (nm)=n×(n−1)×⋯×(n−m+1)m!\binom{n}{m} = \frac{n \times (n - 1) \times \dots \times (n - m + 1)}{m!},可以将 (nm)\binom{n}{m} 看成一个关于 nn 的 mm 次多项式。

    记多项式 Fi(x)=x−i+1iF_i(x) = \frac{x - i + 1}{i}(特别地 F0(x)=1F_0(x) = 1),则单次查询的答案为

    ∑i=0m∏j=0iFj(n)\sum_{i = 0}^m\prod_{j = 0}^i F_j(n)

    记 M=max⁡{m}M = \max\{m\},对区间 [0,M+1][0, M + 1] 建立线段树。将询问 n,mn, m 挂在叶子节点 [m+1,m+1][m + 1, m + 1] 上。

    对于线段树上表示区间 [l,r][l, r] 的节点 uu,预处理出:

    • ∏i=lrFi(x)\prod_{i = l}^r F_i(x)。
    • ∑i=lr∏j=liFj(x)\sum_{i = l}^r \prod_{j = l}^i F_j(x)。

    在线段树上递归,假设当前递归到了表示区间 [l,r][l, r] 的节点 uu,维护当前的 ∏i=0l−1Fi(x)\prod_{i = 0}^{l - 1} F_i(x) 与 ∑i=0l−1∏j=0iFj(x)\sum_{i = 0}^{l - 1} \prod_{j = 0}^i F_j(x)。在递归的过程中,两个多项式的次数太大,无法承受。

    考虑运用多项式多点求值的经典套路 f(x)≡f(n)(modx−n)f(x) \equiv f(n) \pmod{x - n}。

    递归到节点 uu 的时候,将两个多项式均对 ∏m+1∈[l,r](x−n)\prod_{m + 1\in [l, r]} (x - n) 取模(也就是对区间内所有询问的 x−nx - n 之积取模,同样在线段树上预处理出,注意叶子可能有多个询问,乘积需要单独计算),此时两个多项式的次数均不超过区间内询问个数。

    最后递归到叶子时,由于叶子可能有多个询问,对当前多项式进行多点求值即可。

    时间复杂度 O(Mlog⁡2M+Qlog⁡2Q)\mathcal{O}(M \log^2 M + Q \log^2 Q),该做法的优点是时间复杂度与 nn 无关。

    还有一种基于莫队的做法。记 Sn,m=∑i=0m(ni)S_{n, m} = \sum_{i = 0}^m \binom{n}{i},则有

    Sn+1,m=2Sn,m−(nm)Sn,m+1=Sn,m+(nm+1)\begin{gathered} S_{n + 1, m} = 2S_{n, m} - \binom{n}{m} \\ S_{n, m + 1} = S_{n, m} + \binom{n}{m + 1} \end{gathered}

    Model:半在线卷积

    半在线卷积:给出 g1,…,gng_1, \dots, g_n,求出 f0,…,fnf_0, \dots, f_n,其中 f0=1f_0 = 1,fi=∑j=1ifi−jgjf_i = \sum_{j = 1}^i f_{i - j}g_j。

    使用按中序遍历转移的 CDQ 分治:设 solve(l,r)\mathrm{solve}(l, r) 表示求出区间 [l,r][l, r] 中所有的 ff 值,取 mid=⌊l+r2⌋\mathrm{mid} = \lfloor \frac{l + r}{2} \rfloor。

    • 先递归 solve(l,mid)\mathrm{solve}(l, \mathrm{mid}),求出 fl,…,fmidf_l, \dots, f_{\mathrm{mid}}。
    • 计算 f[l,mid]f_{[l, \mathrm{mid}]} 与 g[0,r−l]g_{[0, r - l]} 的卷积结果,求出左半区间对右半区间的贡献。
    • 后递归 solve(mid+1,r)\mathrm{solve}(\mathrm{mid} + 1, r),求出 fmid+1,…,frf_{\mathrm{mid} + 1}, \dots, f_r。
    • 递归到叶子 l=rl = r 时,请注意根据具体递推式调整 fif_i(e.g. fi=gi−∑j=1i−1(i−1j)fi−jgjf_i = g_i - \sum_{j = 1}^{i - 1} \binom{i - 1}{j} f_{i - j}g_j)。

    时间复杂度 T(n)=2T(n2)+O(nlog⁡n)=O(nlog⁡2n)T(n) = 2T\left( \frac{n}{2} \right) + \mathcal{O}(n \log n) = \mathcal{O}(n \log^2 n)。

    卡常技巧:计算 f[l,mid]f_{[l, \mathrm{mid}]} 与 g[0,r−l]g_{[0, r - l]} 的卷积结果时,只需将补充界设定成 ≥len\geq \mathrm{len} 即可(而非 ≥3⋅len2\geq \frac{3 \cdot \mathrm{len}}{2})。

    因为循环卷积只会污染 0∼len20 \sim \frac{\mathrm{len}}{2} 次项,但我们只需要 len2∼len\frac{\mathrm{len}}{2} \sim \mathrm{len} 次项。

    全在线卷积:求出 f0,…,fnf_0, \dots, f_n,其中 f0=1f_0 = 1,fi=∑j=1ifi−jgjf_i = \sum_{j = 1}^i f_{i - j}g_j,但是 gig_i 与 f0,…,fi−1f_0, \dots, f_{i - 1} 强相关。

    仍然使用按中序遍历转移的 CDQ 分治,但 g[0,r−l]g_{[0, r - l]} 我们不一定提前知道。进一步分析分治树的结构,发现仅有 l=0l = 0 时不知道 g[0,r−l]g_{[0, r - l]}。所以我们需要修改计算贡献的方式。

    • 当 l=0l = 0 时,计算 f[0,mid]×g[0,mid]f_{[0, \mathrm{mid}]} \times g_{[0, \mathrm{mid}]} 的贡献(此时还有 f[0,mid]×g[mid+1,r]f_{[0, \mathrm{mid}]} \times g_{[\mathrm{mid} + 1, r]} 的贡献没被计算)。
    • 当 l>0l > 0 时,计算 f[l,mid]×g[0,r−l]+g[l,mid]×f[0,r−l]f_{[l, \mathrm{mid}]} \times g_{[0, r - l]} + g_{[l, \mathrm{mid}]} \times f_{[0, r - l]} 的贡献(后半部分即为 l=0l = 0 中漏掉的贡献)。
    • 递归到叶子 l=rl = r 时,先根据 f0,…,fl−1f_0, \dots, f_{l - 1} 求出 glg_l,再计算 f0×glf_0 \times g_l 的贡献。

    可以证明,点对的贡献不重不漏。

    时间复杂度 O(nlog⁡2n)\mathcal{O}(n \log^2 n)。

    Model:树上路径长度统计

    树上路径长度统计:有一棵包含 nn 个点的树,对于每个 kk (1≤k<n1 \leq k < n) 求出有多少条路径的长度为 kk。

    对树进行点分治,设当前的分治重心为 cc,考虑统计经过当前分治重心的路径贡献。设删除分治重心 cc 之后,剩下的连通块内的点到 cc 的距离分布多项式分别为 b1(x),…,bm(x)b_1(x), \dots, b_m(x),其中 [xk]bi(x)[x^k]b_i(x) 表示第 ii 个连通块有多少个距离 cc 为 kk 的点。

    则分治重心 cc 的贡献多项式为

    ∑i=1mbi(x)(∑j=1i−1bj(x)+1)\sum_{i = 1}^{m} b_i(x) \left( \sum_{j = 1}^{i - 1}b_j(x) + 1 \right)

    将多项式 b1(x),…,bm(x)b_1(x), \dots, b_m(x) 按照次数从小到大排序后,维护一个前缀多项式之和,计算上式即可。

    时间复杂度 O(nlog⁡2n)\mathcal{O}(n \log^2 n)。

    还有一种基于长链剖分的做法,时间复杂度 O(nlog⁡n)\mathcal{O}(n \log n),详见 zak 的博客。

    多项式基本运算

    多项式除法(暴力)

    多项式除法:给出两个多项式 A(x),B(x)A(x), B(x),求出多项式 C(x)C(x),满足 B(x)C(x)=A(x)B(x)C(x) = A(x)。

    设 A(x)=∑i=0naixi,B(x)=∑i=0mbixi,C(x)=∑i=0n−mcixiA(x) = \sum_{i = 0}^n a_ix^i, B(x) = \sum_{i = 0}^m b_ix^i, C(x) = \sum_{i = 0}^{n - m}c_ix^i。先对 bb 的前导零进行处理,设 bb 的前导零有 tt 位,则需要使得 a,ba, b 左移 tt 位。然后直接根据定义 ∑j=0icjbi−j=ai\sum_{j = 0}^ic_jb_{i - j} = a_i 暴力展开。

    初值

    c0=a0b0c_0 = \frac{a_0}{b_0}

    递推式

    ci=1b0(ai−∑j=0i−1cjbi−j)c_i = \frac{1}{b_0}\left( a_i - \sum_{j = 0}^{i - 1}c_jb_{i - j} \right)

    但递推式里的 jj 只需要枚举到 i−j≤mi - j \leq m 即 j≥i−mj \geq i - m 就可以了。

    时间复杂度 O(nm)\mathcal{O}(nm)。实际上是 (n−m)m(n - m)m。

    多项式导数/积分

    多项式形式导数:

    f′(x)=(∑i=0naixi)′=∑i=1niaixi−1f'(x) = \left( \sum\limits_{i = 0}^na_ix^i \right)' = \sum\limits_{i = 1}^n ia_ix^{i - 1}

    多项式形式积分:

    ∫f(x)dx=∫(∑i=0naixi)dx=∑i=0n1i+1aixi+1\int f(x) \mathrm{dx} = \int \left( \sum\limits_{i = 0}^n a_ix^i \right) \mathrm{dx} = \sum\limits_{i = 0}^n \frac{1}{i + 1}a_ix^{i + 1}

    多项式牛顿迭代

    多项式牛顿迭代:已知多项式函数 gg,求出满足 g(h(x))=0g(h(x)) = 0 的多项式 hh,一般我们只需要求出 h mod xnh \bmod x^n。

    (在这里,我们将 f(x)f(x) 看成函数 g(f(x))g(f(x)) 的自变量,则我们要求的就是 g(f(x))=0g(f(x)) = 0 模 xnx^n 意义下的零点)。

    当 n=1n = 1 时,[x0]h(x)[x^0]h(x) 需要单独求出。

    当 n>1n > 1 时,记 h0=h mod x⌈n2⌉,h1=h mod xnh_0 = h \bmod x^{\left\lceil \frac{n}{2} \right\rceil}, h_1 = h \bmod x^n,假设现在已经求出了 h0h_0,希望通过 h0h_0 推出 h1h_1。考虑将函数 g(f(x))g(f(x)) 在 f(x)=h0(x)f(x) = h_0(x) 处泰勒展开。

    g(f(x))=∑i=0∞g(i)(h0(x))i!(f(x)−h0(x))ig(f(x)) = \sum\limits_{i = 0}^{\infty} \frac{g^{(i)}(h_0(x))}{i!}(f(x) - h_0(x))^i

    将 h1(x)h_1(x) 代入自变量 f(x)f(x),观察到 h1(x)−h0(x)h_1(x) - h_0(x) 的前 ⌈n2⌉\left\lceil \frac{n}{2} \right\rceil 项均为 00,所以二次及以上的项均可忽略。进一步可得

    g(h0(x))+g′(h0(x))(h1(x)−h0(x))≡0(modxn)g(h_0(x)) + g'(h_0(x))\left( h_1(x) - h_0(x) \right) \equiv 0 \pmod{x^n}

    移项可得

    h1(x)≡h0(x)−g(h0(x))g′(h0(x))(modxn)h_1(x) \equiv h_0(x) - \frac{g(h_0(x))}{g'(h_0(x))} \pmod{x^n}

    时间复杂度 T(n)=T(n2)+O(nlog⁡n)=O(nlog⁡n)T(n) = T\left(\frac{n}{2}\right) + \mathcal{O}(n \log n) = \mathcal{O}(n \log n)。

    多项式求逆

    多项式逆:给出一个多项式 A(x)A(x),求出多项式 B(x)B(x),满足 A(x)B(x)=1A(x)B(x) = 1。一般只需要求出 B mod xmB \bmod{x^m}。

    多项式逆存在条件:多项式 A(x)A(x) 存在逆,当且仅当 [x0]A(x)≠0[x^0]A(x) \neq 0。

    (注意:一个多项式的逆可能是有无穷项的,例如 11−x=1+x+x2+…\frac{1}{1 - x} = 1 + x + x^2 + \dots)

    多项式求逆(牛顿迭代):

    构造函数 g(f(x))=1f(x)−A(x)g(f(x)) = \frac{1}{f(x)} - A(x),代入牛顿迭代法得

    h1(x)≡h0(x)−1h0(x)−A(x)−1h02(x)(modxm)h1(x)≡2h0(x)−A(x)h02(x)(modxm)\begin{gathered} h_1(x) \equiv h_0(x) - \frac{\frac{1}{h_0(x)} - A(x)}{-\frac{1}{h_0^2(x)}} \pmod{x^m} \\ h_1(x) \equiv 2h_0(x) - A(x)h_0^2(x) \pmod{x^m} \end{gathered}

    初始时,A−1(x)A^{-1}(x) 的常数项即为 A(x)A(x) 常数项的逆元。

    时间复杂度 O(mlog⁡m)\mathcal{O}(m \log m)。

    多项式开方

    多项式开方:给出一个多项式 A(x)A(x),求出多项式 B(x)B(x),满足 B2(x)=A(x)B^2(x) = A(x)。一般只需要求出 B mod xmB \bmod x^m。

    多项式开方存在条件:当 [x0]A(x)≠0[x^0]A(x) \neq 0 时,多项式 A(x)A(x) 存在开方,当且仅当 [x0]A(x)[x^0]A(x) 是模意义下的二次剩余。

    构造函数 g(f(x))=f2(x)−A(x)g(f(x)) = f^2(x) - A(x),代入牛顿迭代法得

    h1(x)≡h0(x)−h02(x)−A(x)2h0(x)(modxm)h1(x)≡h02(x)+A(x)2h0(x)(modxm)\begin{gathered} h_1(x) \equiv h_0(x) - \frac{h_0^2(x) - A(x)}{2h_0(x)} \pmod{x^m} \\ h_1(x) \equiv \frac{h_0^2(x) + A(x)}{2h_0(x)} \pmod{x^m} \end{gathered}

    初始时,A(x)\sqrt{A(x)} 的常数项即为 A(x)A(x) 常数项模意义下的平方根。当 A(x)A(x) 常数项不等于 11 时,还需要通过二次剩余求解常数项。

    时间复杂度 O(mlog⁡m)\mathcal{O}(m \log m)。

    By the way:注意到 A(x)=e12ln⁡A(x)\sqrt{A(x)} = e^{\frac{1}{2}\ln A(x)},若 [x0]A(x)=1[x^0]A(x) = 1,可以直接套用多项式 ln/exp。

    多项式带余除法

    多项式带余除法:给出一个 nn 次多项式 A(x)A(x) 和一个 mm 次多项式 B(x)B(x),求出多项式 Q(x),R(x)Q(x), R(x) 满足:

    • Q(x)Q(x) 的次数为 n−mn - m,R(x)R(x) 的次数 <m<m。
    • A(x)=Q(x)×B(x)+R(x)A(x) = Q(x) \times B(x) + R(x)。

    考虑构造变换 fR(x)=xdegff(1x)f^R(x) = x^{\mathrm{deg} f} f\left(\frac{1}{x}\right),实际上即为翻转 ff 的系数。

    将 A(x)=Q(x)×B(x)+R(x)A(x) = Q(x) \times B(x) + R(x) 中的 xx 替换为 1x\frac{1}{x},并且等式两边同乘以 xnx^n

    xnA(1x)=xn−mQ(1x)×xmB(1x)+xn−m+1xm−1R(1x)AR(x)=QR(x)×BR(x)+xn−m+1xm−1R(1x)AR(x)≡QR(x)×BR(x)(modxn−m+1)\begin{gathered} x^nA\left(\frac{1}{x}\right) = x^{n - m}Q\left(\frac{1}{x}\right) \times x^mB\left(\frac{1}{x}\right) + x^{n - m + 1}x^{m - 1} R\left(\frac{1}{x}\right) \\ A^R(x) = Q^R(x) \times B^R(x) + x^{n - m + 1}x^{m - 1}R\left(\frac{1}{x}\right) \\ A^R(x) \equiv Q^R(x) \times B^R(x) \pmod{x^{n - m + 1}} \end{gathered}

    由于 Q(x)Q(x) 的次数小于 n−m+1n - m + 1,故对 xn−m+1x^{n - m + 1} 取模没有影响。

    故在模 xn−m+1x^{n - m + 1} 意义下求出 AR(x)BR(x)\frac{A^R(x)}{B^R(x)} 再翻转一遍即可求出 Q(x)Q(x),再使用 A(x)−Q(x)×B(x)A(x) - Q(x) \times B(x) 即可求出 R(x)R(x)。

    时间复杂度 O(nlog⁡n)\mathcal{O}(n \log n)。

    多项式 ln/exp

    ee 在模 998244353998244353 下没有意义。同理,ln⁡2\ln 2 在模 998244353998244353 下没有意义。

    简单的解释:考察 e=∑i=0∞1i!e = \sum_{i = 0}^\infty \frac{1}{i!},在 i≥998244353i \geq 998244353 时,分式就已经失去了意义。即使有意义,无穷项求和在模 998244353998244353 下也不会收敛。

    多项式 ln 与多项式 exp 的定义:由麦克劳林级数定义

    ln⁡f(x)=∑i=1∞(−1)i+1(f(x)−1)ii=−∑i=1∞(1−f(x))iiexp⁡f(x)=∑i=0∞fi(x)i!\begin{aligned} \ln f(x) & = \sum\limits_{i = 1}^{\infty} (-1)^{i + 1} \frac{(f(x) - 1)^i}{i} \\ & = - \sum\limits_{i = 1}^{\infty} \frac{(1 - f(x))^i}{i} \\ \exp f(x) & = \sum\limits_{i = 0}^{\infty} \frac{f^i(x)}{i!} \end{aligned}

    多项式 ln 存在条件:多项式 f(x)f(x) 存在 ln,当且仅当 [x0]f(x)=1[x^0]f(x) = 1,并且由此可得 [x0]ln⁡f(x)=0[x^0] \ln f(x) = 0。

    多项式 ln:给出一个多项式 A(x)A(x),求出多项式 B(x)=ln⁡A(x)B(x) = \ln A(x)。一般只需要求出 B mod xmB \bmod{x^m}。

    将 B(x)=ln⁡A(x)B(x) = \ln A(x) 等式两边对 xx 求导可得

    B′(x)=A′(x)A(x)B'(x) = \frac{A'(x)}{A(x)}

    两边同时积分可得

    B(x)=∫A′(x)A(x)dxB(x) = \int \frac{A'(x)}{A(x)} \mathrm{dx}

    注意:虽然多项式先求导后积分会丢掉常数项的信息,但是容易验证当 A(x)A(x) 的常数项为 11 时,B(x)B(x) 的常数项必定为 00。

    时间复杂度 O(mlog⁡m)\mathcal{O}(m \log m)。

    多项式 exp 存在条件:多项式 f(x)f(x) 存在 exp,当且仅当 [x0]f(x)=0[x^0]f(x) = 0,并且可以推出 [x0]exp⁡f(x)=1[x^0]\exp f(x) = 1。

    多项式 exp:给出一个多项式 A(x)A(x),求出多项式 B(x)=exp⁡A(x)B(x) = \exp A(x)。一般只需要求出 B mod xmB \bmod{x^m}。

    构造函数 g(f(x))=ln⁡f(x)−A(x)g(f(x)) = \ln f(x) - A(x),代入牛顿迭代得

    h1(x)≡h0(x)−ln⁡h0(x)−A(x)1h0(x)(modxm)h1(x)≡h0(x)(1−ln⁡h0(x)+A(x))(modxm)\begin{gathered} h_1(x) \equiv h_0(x) - \frac{\ln h_0(x) - A(x)}{\frac{1}{h_0(x)}} \pmod{x^m} \\ h_1(x) \equiv h_0(x)\left( 1 - \ln h_0(x) + A(x) \right) \pmod{x^m} \end{gathered}

    初始时,exp⁡A(x)\exp A(x) 的常数项必为 11。

    时间复杂度 O(mlog⁡m)\mathcal{O}(m \log m)。

    多项式快速幂

    多项式快速幂:给出一个多项式 A(x)A(x),你需要求出 Ak(x) mod xmA^k(x) \bmod{x^m}。

    多项式快速幂(倍增法):具体算法流程同快速幂。

    时间复杂度 O(mlog⁡mlog⁡k)\mathcal{O}(m \log m \log k),但可以处理的问题形式更加灵活。

    e.g. 多项式快速幂对另一多项式取模。

    e.g. 多项式快速幂且保留次数在 [−m,m][-m, m] 的项。

    多项式快速幂(先 ln 后 exp):注意到 Ak(x)=ekln⁡A(x)A^k(x) = e^{k\ln A(x)},考虑直接套用多项式 ln 与多项式 exp 的模板。

    但由于多项式 ln 需要保证 [x0]A(x)=1[x^0]A(x) = 1,首先要对 A(x)A(x) 进行一些操作。

    找出一个最小的 ii,满足 [xi]A(x)≠0[x^i]A(x) \neq 0(相当于是找出 A(x)A(x) 的第一个非零系数),记 v=[xi]A(x)v = [x^i]A(x)。则有

    A(x)=(A(x)xiv)xivA(x) = \left(\frac{A(x)}{x^iv}\right)x^iv

    注意到 A(x)xiv\frac{A(x)}{x^iv} 满足常数项为 11 的限制,可以进行多项式 ln。

    然后有

    Ak(x)=(A(x)xiv)kxikvkA^k(x) = \left(\frac{A(x)}{x^iv}\right)^k x^{ik}v^k

    先使用多项式 ln 与多项式 exp 求出 (A(x)xiv)k mod xm−ik\left(\frac{A(x)}{x^iv}\right)^k \bmod{x^{m - ik}} 的值,最后再乘上 xikvkx^{ik}v^k 即可。

    (注意:这里的乘 xikx^{ik} 相当于多项式系数向右移动 ikik 位。上面的除以 xix^i 同理,相当于多项式系数向左移动 ii 位,即舍弃掉前 ii 项系数)

    时间复杂度 O(mlog⁡m)\mathcal{O}(m \log m)。

    设模数为质数 PP。当 k≤Pk \leq P 时,可以放心应用该做法;当 k>Pk > P 时,需要进一步讨论 kk 的取模相关问题。

    由 (a+b)P≡aP+bP(modP)(a + b)^P \equiv a^P + b^P \pmod P 以及费马小定理可得 fP(x)≡f(xP)(modP)f^P(x) \equiv f(x^P) \pmod P。

    在一般情况下 P>mP > m,所以 fP(x)≡f(xP)≡[x0]f(x)(modxm)f^P(x) \equiv f(x^P) \equiv [x^0]f(x) \pmod{x^m},由于我们进行了一系列操作使得 [x0]f(x)=1[x^0]f(x) = 1,所以 fP(x)≡1(modxm)f^P(x) \equiv 1 \pmod{x^m}。于是:

    • 多项式 ln/exp 部分:kk 需要对 PP 取模。
    • vkv^k 部分:kk 需要对 φ(P)=P−1\varphi(P) = P - 1 取模(因为是数值计算)。
    • xikx^{ik} 部分:用原始的 kk 判断,当 i>0i > 0 且 k≥mk \geq m 时答案必定为 00。

    少项式快速幂

    少项式快速幂:给出一个次数不高的多项式 A(x)A(x),求出 Ak(x) mod xmA^k(x) \bmod x^m。

    该做法需要满足 [x0]A(x)≠0[x^0]A(x) \neq 0,可以对前导 00 特殊处理。

    设 A(x)=∑i=0naixi,Ak(x)=∑i=0m−1bixiA(x) = \sum_{i = 0}^n a_ix^i, A^k(x) = \sum_{i = 0}^{m - 1}b_ix^i。考虑对 Ak(x)A^k(x) 求导

    Ak(x)′=kAk−1(x)A′(x)Ak(x)′A(x)=kAk(x)A′(x)\begin{gathered} A^k(x)' = kA^{k - 1}(x)A'(x) \\ \textcolor{blue}{A^k(x)'}A(x) = k\textcolor{blue}{A^{k}(x)}A'(x) \end{gathered}

    注意到 Ak(x)A^k(x) 与 Ak(x)′A^k(x)' 有一定的递推关系。具体地,考虑等式左右两边的 ii 次项

    ∑j=0i(j+1)bj+1ai−j=k⋅∑j=0i(i−j+1)ai−j+1bj\sum\limits_{j = 0}^i (j + 1)b_{j + 1}a_{i - j} = k\cdot \sum_{j = 0}^i(i - j + 1)a_{i - j + 1}b_j

    等式左边只需枚举到 j≥i−nj \geq i - n,等式右边只需枚举到 j≥i−n+1j \geq i - n + 1。可以解得

    bi+1=(k⋅∑j=i−n+1i(i−j+1)ai−j+1bj)−(∑j=i−ni−1(j+1)bj+1ai−j)(i+1)a0b_{i + 1} = \frac{\left( k\cdot \sum\limits_{j = i - n + 1}^{i} (i - j + 1)a_{i - j + 1}b_j \right) - \left( \sum\limits_{j = i - n}^{i - 1}(j + 1)b_{j + 1}a_{i - j} \right)}{(i + 1)a_0}

    初值 b0=a0kb_0 = a_0^k,上式可以在已知 b0,b1,…,bib_0, b_1, \dots, b_i 的情况下递推出 bi+1b_{i + 1}。

    需要线性预处理出 1,2,…,m−11, 2, \dots, m - 1 的逆元,递推式:i−1≡−⌊pi⌋(p mod i)−1(modp)i^{-1} \equiv -\left\lfloor \frac{p}{i} \right\rfloor (p \bmod i)^{-1} \pmod{p}。

    时间复杂度 O(nm)\mathcal{O}(nm)。当次数 nn 较小时有奇效。

    By the way:从这个递推式进行归纳可知,当 a0=1a_0 = 1 时,[xn]Ak(x)[x^n]A^k(x) 是一个关于 kk 的至多 nn 次多项式。

    转置原理

    待填坑。

    多项式多点求值

    多项式多点求值:给出一个多项式 f(x)f(x) 和 nn 个点 x1,…,xnx_1, \dots, x_n,求 f(x1),…,f(xn)f(x_1), \dots, f(x_n)。

    多项式多点求值(多项式取模):

    设 mid=⌊1+n2⌋\mathrm{mid} = \left\lfloor \frac{1 + n}{2} \right\rfloor,将给定的点集分成两部分

    X1={x1,…,xmid},X2={xmid+1,…,xn}X_1 = \{ x_1, \dots, x_{\mathrm{mid}} \}, \quad X_2 = \{ x_{\mathrm{mid} + 1}, \dots, x_{n} \}

    构造多项式

    g1(x)=∏xi∈X1(x−xi),g2(x)=∏xi∈X2(x−xi)g_1(x) = \prod\limits_{x_i \in X_1}(x - x_i), \quad g_2(x) = \prod\limits_{x_i \in X_2}(x - x_i)

    将 f(x)f(x) 对 g1(x)g_1(x) 取模,记 f(x)=Q1(x)×g1(x)+R1(x)f(x) = Q_1(x) \times g_1(x) + R_1(x)。对于 X1X_1 中的元素 xix_i,由于 g1(xi)=0g_1(x_i) = 0,则有 f(xi)=R1(xi)f(x_i) = R_1(x_i)。又由于 R1(x)R_1(x) 的次数小于区间长度的一半,于是问题规模成功减半,分治求解问题即可。对于 X2X_2 中的元素也是同理。

    多项式 gg 可以通过分治 NTT 预处理。

    时间复杂度 T(n)=2T(n2)+O(nlog⁡n)=O(nlog⁡2n)T(n) = 2T(\frac{n}{2}) + \mathcal{O}(n \log n) = \mathcal{O}(n \log^2 n)。

    另一种理解角度:f(x)≡f(xi)(modx−xi)f(x) \equiv f(x_i) \pmod{x - x_i}。证明只需将 xn=((x−xi)+xi)nx^n = \left((x - x_i) + x_i\right)^n 二项式定理展开即可。

    0x31 多项式多点求值(多项式取模).cpp:

    // 多项式多点求值(多项式取模做法),作为 poly 的成员函数
    std::vector<int> eval(std::vector<int> x) const {
        if (empty()) return std::vector<int>(x.size());
        if (x.empty()) return {};
    
        int n = x.size();
        std::vector<poly> t(n * 4);
        std::vector<int> ans(n);
    
        std::function<void(int, int, int)> build = [&] (int p, int l, int r) {
            if (l == r) {
                t[p] = poly{norm(-x[l]), 1};
                return;
            }
            int mid = (l + r) >> 1;
            build(p * 2, l, mid), build(p * 2 + 1, mid + 1, r);
            t[p] = t[p * 2] * t[p * 2 + 1];
        };
        build(1, 0, n - 1);
    
        std::function<void(int, int, int, const poly &)> solve = [&] (int p, int l, int r, const poly &f) {
            if (l == r) {
                ans[l] = f[0];
                return;
            }
            int mid = (l + r) >> 1;
            solve(p * 2, l, mid, divmod(f, t[p * 2]).second);
            solve(p * 2 + 1, mid + 1, r, divmod(f, t[p * 2 + 1]).second);
        };
        solve(1, 0, n - 1, divmod(*this, t[1]).second);
    
        return ans;
    }

    多项式多点求值(转置原理):

    待填坑。

    多项式快速插值

    多项式快速插值:给出 nn 个点 (x1,y1),(x2,y2),…,(xn,yn)(x_1, y_1), (x_2, y_2), \dots, (x_n, y_n),其中横坐标(模意义下)两两不同。快速地求一个至多为 n−1n - 1 次多项式,使得这 nn 个点都在 f(x)f(x) 上。

    考虑拉格朗日插值

    f(x)=∑i=1nyi∏j≠ix−xjxi−xjf(x) = \sum\limits_{i = 1}^{n}y_i \prod\limits_{j \neq i} \frac{x - x_j}{x_i - x_j}

    记 g(x)=∏j=1n(x−xj)g(x) = \prod_{j = 1}^n(x - x_j),则

    ∏j≠i(xi−xj)=lim⁡x→xi∏j=1n(x−xj)x−xi=g′(xi)\prod_{j \neq i} (x_i - x_j) = \lim_{x \to x_i} \frac{\prod_{j = 1}^n (x - x_j)}{x - x_i} = g'(x_i)

    首先使用分治 NTT 求出 g′(x)g'(x),再使用多项式多点求值,求出所有的 g′(xi)g'(x_i)。

    记 vi=yig′(xi)v_i = \frac{y_i}{g'(x_i)},则原式化为

    f(x)=∑i=1nvi∏j≠i(x−xj)f(x) = \sum\limits_{i = 1}^n v_i \prod\limits_{j \neq i} (x - x_j)

    仍然使用分治 NTT 求出上式。具体地,设 mid=⌊1+n2⌋\mathrm{mid} = \left\lfloor \frac{1 + n}{2} \right\rfloor,设多项式

    f1(x)=∑i=1midvi(∏j≠i,j≤mid(x−xj)),g1(x)=∏j≤mid(x−xj)f2(x)=∑i=mid+1nvi(∏j≠i,j>mid(x−xj)),g2(x)=∏j>mid(x−xj)\begin{gathered} f_1(x) = \sum\limits_{i = 1}^\mathrm{mid} v_i \left( \prod\limits_{j \neq i, j \leq \mathrm{mid}} (x - x_j) \right), \quad g_1(x) = \prod\limits_{j \leq \mathrm{mid}} (x - x_j) \\ f_2(x) = \sum\limits_{i = \mathrm{mid} + 1}^n v_i \left( \prod\limits_{j \neq i, j > \mathrm{mid}} (x - x_j) \right), \quad g_2(x) = \prod\limits_{j > \mathrm{mid}} (x - x_j) \end{gathered}

    显然有 f(x)=f1(x)g2(x)+f2(x)g1(x)f(x) = f_1(x)g_2(x) + f_2(x)g_1(x)。f1,f2,g1,g2f_1, f_2, g_1, g_2 可以进一步分治求解。

    时间复杂度 O(nlog⁡2n)\mathcal{O}(n \log^2 n)。

    多项式平移

    多项式平移:给出一个多项式 A(x)A(x) 以及一个常数 cc,求出多项式 A(x+c)A(x + c)。

    多项式平移(二项式定理法):设 A(x)=∑i=0naixiA(x) = \sum_{i = 0}^n a_ix^i,考虑二项式定理

    A(x+c)=∑i=0nai(x+c)i=∑i=0nai∑j=0i(ij)xjci−j=∑i=0nai∑j=0ii!j!(i−j)!xjci−j=∑j=0nxjj!⋅(∑i=jnai⋅i!⋅ci−j(i−j)!)\begin{aligned} A(x + c) & = \sum_{i = 0}^n a_i(x + c)^i \\ & = \sum_{i = 0}^n a_i \sum_{j = 0}^i \binom{i}{j}x^jc^{i - j} \\ & = \sum_{i = 0}^n a_i \sum_{j = 0}^i \frac{i!}{j!(i - j)!}x^jc^{i - j} \\ & = \sum_{j = 0}^n \frac{x^j}{j!} \cdot \left( \sum_{i = j}^n \textcolor{red}{ a_i \cdot i!} \cdot \textcolor{blue}{ \frac{c^{i - j}}{(i - j)!}} \right) \\ \end{aligned}

    注意到括号里的求和式,下标之差恒为 jj,于是可以使用“翻转卷积”的技巧求出每个关于 jj 的求和式。

    时间复杂度 O(nlog⁡n)\mathcal{O}(n \log n)。

    连续点值平移:给出 n+1n + 1 个连续点值 f(0),f(1),…,f(n)f(0), f(1), \dots, f(n)(其中 ff 是一个次数至多为 nn 的多项式)以及一个常数 cc,求出 f(c),f(c+1),…,f(c+n)f(c), f(c + 1), \dots, f(c + n)。

    代入拉格朗日插值公式,得

    f(x)=∑i=0nyi∏j≠ix−ji−j=∑i=0nyi⋅∏v=x−nxvx−i⋅(−1)n−ii!(n−i)!=(∏v=x−nxv)∑i=0n1x−i⋅yi(−1)n−ii!(n−i)!\begin{aligned} f(x) & = \sum_{i = 0}^n y_i \prod_{j \neq i} \frac{x - j}{i - j} \\ & = \sum_{i = 0}^n y_i \cdot \frac{\prod_{v = x - n}^{x} v}{x - i} \cdot \frac{(-1)^{n - i}}{i!(n - i)!} \\ & = \left(\prod_{v = x - n}^{x} v\right) \sum_{i = 0}^n \frac{1}{x - i} \cdot \frac{y_i(-1)^{n - i}}{i!(n - i)!} \end{aligned}

    于是

    f(c+x)=(∏v=c+x−nc+xv)∑i=0n1c+x−i⋅yi(−1)n−ii!(n−i)!f(c + x) = \left( \prod_{v = c + x - n}^{c + x} v \right)\sum_{i = 0}^n \frac{1}{c + x - i} \cdot \frac{y_i(-1)^{n - i}}{i!(n - i)!}

    注意到右边的求和式,是一个卷积的形式。但是 1c+x−i\frac{1}{c + x - i} 的分母在模意义下可能为 00,此时 c+x≡i(modp)c + x \equiv i \pmod{p},于是 f(c+x)≡f(i)≡yi(modp)f(c + x) \equiv f(i) \equiv y_i \pmod{p},所以此时该点值不需要额外计算,直接取已有的值 yiy_i 即可。

    记:

    • ai={1c−n+ic−n+i≢0(modp)0c−n+i≡0(modp)a_i = \begin{cases} \frac{1}{c - n + i} & c - n + i \not\equiv 0 \pmod{p} \\ 0 & c - n + i \equiv 0 \pmod{p} \end{cases}(其中 i=0∼2ni = 0 \sim 2n,因为分母的取值范围为 [c−n,c+n][c - n, c + n])。
    • bi=yi(−1)n−ii!(n−i)!b_i = \frac{y_i(-1)^{n - i}}{i!(n - i)!}。

    则右边的求和式为 ∑i=0nax−i+nbi\sum_{i = 0}^n a_{x - i + n}b_i。将 a,ba, b 进行卷积得到 res\mathrm{res}。此时,若 (c+x) mod p∈[0,n](c + x) \bmod p \in [0, n],则

    f(c+x)=y(c+x) mod pf(c + x) = y_{(c + x) \bmod p}

    否则

    f(c+x)=(∏v=c+x−nc+xv)resx+nf(c + x) = \left( \prod_{v = c + x - n}^{c + x} v \right) \mathrm{res}_{x + n}

    时间复杂度 O(nlog⁡n)\mathcal{O}(n \log n)。

    给出 n+1n + 1 个等差点值 f(b),f(b+k),…,f(b+nk)f(b), f(b + k), \dots, f(b + nk)(其中 ff 是一个次数至多为 nn 的多项式) 以及一个常数 cc,求出 f(c+b),f(c+b+k),…,f(c+b+nk)f(c + b), f(c + b + k), \dots, f(c + b + nk)。

    设 g(x)=f(b+xk)g(x) = f(b + xk),可以看成 g(0),g(1),…,g(n)g(0), g(1), \dots, g(n) 向右平移 ck\frac{c}{k} 得到 g(ck),g(ck+1),…,g(ck+n)g(\frac{c}{k}), g(\frac{c}{k} + 1), \dots, g(\frac{c}{k} + n)。

    Chirp Z-Transform

    Chirp Z-Transform:给出一个 nn 次多项式 f(x)f(x) 以及整数 c,mc, m,求出 f(c0),f(c1),…,f(cm−1)f(c^0), f(c^1), \dots, f(c^{m - 1})。

    利用 ij=(i+j2)−(i2)−(j2)ij = \binom{i + j}{2} - \binom{i}{2} - \binom{j}{2},有

    f(ci)=∑j=0najcij=∑j=0najc(i+j2)−(i2)−(j2)=c−(i2)∑j=0najc−(j2)c(i+j2)\begin{aligned} f(c^i) & = \sum\limits_{j = 0}^n a_jc^{ij} \\ & = \sum\limits_{j = 0}^n a_jc^{\binom{i + j}{2} - \binom{i}{2} - \binom{j}{2}} \\ & = c^{-\binom{i}{2}}\sum\limits_{j = 0}^n a_jc^{-\binom{j}{2}} c^{\binom{i + j}{2}} \end{aligned}

    注意到求和式的下标之差恒为 ii,于是可以使用“翻转卷积”的技巧求出每个关于 ii 的求和式。

    多项式全家桶

    reference:jiangly 算法模板。

    封装理念:

    • 构建结构体 poly 继承自 std::vector<int>,自由度高且易于访问。
    • 涉及“当前多项式的变换或求值”的功能均作为 poly 的内置函数;其余功能作为 poly 的外置函数。

    0x31 多项式全家桶.cpp:

    std::vector<int> roots{0, 1};
    void dft(std::vector<int> &a) {
        int n = a.size();
        for (int i = 1, j = 0; i < n; i ++) {
            for (int k = n >> 1; (j ^= k) < k; k >>= 1);
            if (i < j) std::swap(a[i], a[j]);
        }
        for (int k = roots.size(); k < n; k <<= 1) {
            int w = qpow(3, (mod - 1) / (k << 1), mod); // 原根根据实际模数调整
            roots.resize(k << 1);
            for (int i = k >> 1; i < k; i ++) {
                roots[i * 2] = roots[i];
                roots[i * 2 + 1] = 1ll * roots[i] * w % mod;
            }
        }
        for (int k = 1; k < n; k <<= 1) {
            for (int i = 0; i < n; i += (k << 1)) {
                for (int j = 0; j < k; j ++) {
                    int u = a[i + j], v = 1ll * a[i + j + k] * roots[k + j] % mod;
                    add(a[i + j] = u, v), dec(a[i + j + k] = u, v);
                }
            }
        }
    }
    void idft(std::vector<int> &a) {
        int n = a.size(), inv = (1 - mod) / n + mod;
        std::reverse(a.begin() + 1, a.end());
        dft(a);
        for (int i = 0; i < n; i ++) {
            mul(a[i], inv);
        }
    }
    
    // 多项式全家桶(2026-11-05)
    struct poly : public std::vector<int> {
        using std::vector<int>::vector;
        explicit poly(const std::vector<int> &a) : std::vector<int>(a) {}
    
        // 多项式乘法
        friend poly operator * (poly a, poly b) {
            int tot = a.size() + b.size() - 1;
            if (tot < 128) {
                poly c(tot);
                for (int i = 0; i < a.size(); i ++) {
                    for (int j = 0; j < b.size(); j ++) {
                        c[i + j] = (c[i + j] + 1ll * a[i] * b[j]) % mod;
                    }
                }
                return c;
            }
            int L = 1;
            while (L < tot) L <<= 1;
            a.resize(L), b.resize(L);
            dft(a), dft(b);
            for (int i = 0; i < L; i ++) {
                mul(a[i], b[i]);
            }
            idft(a);
            a.resize(tot);
            return a;
        }
    
        // 多项式乘法(暴力)
        friend poly mul_bf(poly a, poly b) {
            poly c(a.size() + b.size() - 1);
            for (int i = 0; i < a.size(); i ++) {
                for (int j = 0; j < b.size(); j ++) {
                    c[i + j] = (c[i + j] + 1ll * a[i] * b[j]) % mod;
                }
            }
            return c;
        }
        // 多项式除法(暴力)
        friend poly div_bf(poly a, poly b) {
            int t = 0;
            while (t < b.size() && b[t] == 0) t ++;
            if (t == b.size()) return poly(a.size() - b.size() + 1); // 除以全 0 多项式无意义
            a = poly(a.begin() + t, a.end());
            b = poly(b.begin() + t, b.end());
            int m = b.size() - 1, inv = qpow(b[0], mod - 2, mod);
            poly c(a.size() - b.size() + 1);
            for (int i = 0; i < c.size(); i ++) {
                c[i] = a[i];
                for (int j = std::max(0, i - m); j < i; j ++) {
                    dec(c[i], 1ll * c[j] * b[i - j] % mod);
                }
                mul(c[i], inv);
            }
            return c;
        }
        
        friend poly operator + (poly a, poly b) {
            poly c(std::max(a.size(), b.size()));
            for (int i = 0; i < a.size(); i ++) add(c[i], a[i]);
            for (int i = 0; i < b.size(); i ++) add(c[i], b[i]);
            return c;
        }
        friend poly operator - (poly a, poly b) {
            poly c(std::max(a.size(), b.size()));
            for (int i = 0; i < a.size(); i ++) add(c[i], a[i]);
            for (int i = 0; i < b.size(); i ++) dec(c[i], b[i]);
            return c;
        }
        friend poly operator - (poly a) {
            for (int &x : a) neg(x);
            return a;
        }
    
        friend poly operator * (poly a, int b) {
            for (int &x : a) mul(x, b);
            return a;
        }
        friend poly operator / (poly a, int b) {
            int inv = qpow(b, mod - 2, mod);
            for (int &x : a) mul(x, inv);
            return a;
        }
    
        poly &operator += (poly b) {
            return *this = *this + b;
        }
        poly &operator -= (poly b) {
            return *this = *this - b;
        }
        poly &operator *= (poly b) {
            return *this = *this * b;
        }
        poly &operator *= (int b) {
            return *this = *this * b;
        }
        poly &operator /= (int b) {
            return *this = *this / b;
        }
    
        poly mulxk(int k) const {
            auto res = *this;
            res.insert(res.begin(), k, 0);
            return res;
        }
        poly divxk(int k) const {
            if (k >= size()) return poly();
            return poly(begin() + k, end());
        }
        poly modxk(int k) const {
            if (k >= size()) return *this;
            return poly(begin(), begin() + k);
        }
        poly cirxk(int k) const {
            auto res = *this;
            for (int i = k; i < size(); i ++) {
                add(res[i % k], res[i]); // 若多项式次数 <2k,可改成 res[i - k]
            }
            return res.modxk(k);
        }
    
        poly flip() const {
            auto res = *this;
            std::reverse(res.begin(), res.end());
            return res;
        }
    
        poly mulT(poly b) const {
            if (b.empty()) return poly();
            std::reverse(b.begin(), b.end());
            return ((*this) * b).divxk(b.size() - 1);
            // 等价于“翻转卷积”,a.mulT(b) 相当于是求 a[i] * b[j] -> c[i - j]
        }
    
        // 多项式导数
        poly deriv() const {
            if (empty()) return poly();
            poly res(size() - 1);
            for (int i = 1; i < size(); i ++) {
                res[i - 1] = 1ll * (*this)[i] * i % mod;
            }
            return res;
        }
    
        // 多项式积分
        poly integ() const {
            poly res(size() + 1);
            for (int i = 0; i < size(); i ++) {
                res[i + 1] = 1ll * (*this)[i] * qpow(i + 1, mod - 2, mod) % mod;
            }
            return res;
        }
    
        // 多项式求逆
        poly inv(int m) const { // 需要保证常数项不为 0
            poly x{qpow(front(), mod - 2, mod)};
            int k = 1;
            while (k < m) {
                k <<= 1;
                x = (x * (poly{2} - modxk(k) * x)).modxk(k);
            }
            return x.modxk(m);
        }
    
        // 多项式开方
        poly sqrt(int m) const {
            poly x{1}; // 默认常数项为 1
            int k = 1;
            while (k < m) {
                k <<= 1;
                x = (x + (modxk(k) * x.inv(k)).modxk(k)) / 2;
            }
            return x.modxk(m);
        }
    
        // 多项式带余除法
        friend std::pair<poly, poly> divmod(poly a, poly b) {
            int n = a.size(), m = b.size(), L = n - m + 1;
            if (n < m) return {poly{0}, a};
            poly q = (a.flip().modxk(L) * b.flip().inv(L)).modxk(L).flip();
            poly r = a - b * q;
            while (r.size() > 1 && !r.back()) {
                r.pop_back();
            }
            return {q, r};
        }
    
        // 多项式 ln
        poly ln(int m) const { // 需要保证常数项为 1
            return (deriv() * inv(m)).integ().modxk(m);
        }
    
        // 多项式 exp
        poly exp(int m) const { // 需要保证常数项为 0
            poly x{1};
            int k = 1;
            while (k < m) {
                k <<= 1;
                x = (x * (poly{1} - x.ln(k) + modxk(k))).modxk(k);
            }
            return x.modxk(m);
        }
    
        // 多项式快速幂
        poly pow(int k, int m) const {
            int i = 0;
            while (i < size() && (*this)[i] == 0) i ++;
            if (i == size() || 1ll * i * k >= m) return poly(m);
            int v = (*this)[i];
            poly f = divxk(i) / v;
            return (f.ln(m - i * k) * k).exp(m - i * k).mulxk(i * k) * qpow(v, k, mod);
            /*
                当实际 k < mod 时,可以放心使用
                当实际 k >= mod 时,请注意:
                - 当 i > 0 时,直接返回 poly(m)
                - 当 i = 0 时
                  - 在多项式 ln 与多项式 exp 部分,k 需要对 mod 取模
                  - 在 qpow(v, k, mod) 部分,k 需要对 mod - 1 取模
            */
        }
        // 少项式快速幂
        poly pow_bf(int k, int m) const { // 需要保证常数项不为 0
            std::vector<int> v(m); // 需要保证 m > 1
            v[1] = 1;
            for (int i = 2; i < m; i ++) {
                v[i] = 1ll * v[mod % i] * (mod - mod / i) % mod;
            }
    
            const poly a = *this;
            int n = a.size() - 1, inv = qpow(a[0], mod - 2, mod);
            poly b(m);
            b[0] = qpow(a[0], k, mod);
            for (int i = 0; i + 1 < m; i ++) {
                for (int j = std::max(0, i - n + 1); j <= i; j ++) {
                    add(b[i + 1], 1ll * (i - j + 1) * a[i - j + 1] % mod * b[j] % mod);
                }
                mul(b[i + 1], k);
                for (int j = std::max(0, i - n); j < i; j ++) {
                    dec(b[i + 1], 1ll * (j + 1) * b[j + 1] % mod * a[i - j] % mod);
                }
                mul(b[i + 1], v[i + 1]), mul(b[i + 1], inv);
            }
            return b;
        }
    
        // 多项式多点求值
        std::vector<int> eval(std::vector<int> x) const {
            if (empty()) return std::vector<int>(x.size());
    
            int n = std::max(x.size(), size());
            std::vector<poly> t(n * 4);
            std::vector<int> ans(x.size());
            x.resize(n);
    
            std::function<void(int, int, int)> build = [&] (int p, int l, int r) {
                if (l == r) {
                    t[p] = poly{1, norm(-x[l])};
                    return;
                }
                int mid = (l + r) >> 1;
                build(p * 2, l, mid), build(p * 2 + 1, mid + 1, r);
                t[p] = t[p * 2] * t[p * 2 + 1];
            };
            build(1, 0, n - 1);
    
            std::function<void(int, int, int, const poly &)> solve = [&] (int p, int l, int r, const poly &num) {
                if (l >= ans.size()) return;
                if (l == r) {
                    ans[l] = num[0];
                    return;
                }
                int mid = (l + r) >> 1;
                solve(p * 2, l, mid, num.mulT(t[p * 2 + 1]).modxk(mid - l + 1));
                solve(p * 2 + 1, mid + 1, r, num.mulT(t[p * 2]).modxk(r - mid));
            };
            solve(1, 0, n - 1, mulT(t[1].inv(n)));
    
            return ans;
        }
    
        // 多项式平移
        poly shift(int c) const {
            int n = size() - 1;
            std::vector<int> fact(n + 1), facv(n + 1);
            fact[0] = 1;
            for (int i = 1; i <= n; i ++) {
                fact[i] = 1ll * fact[i - 1] * i % mod;
            }
            facv[n] = qpow(fact[n], mod - 2, mod);
            for (int i = n - 1; i >= 0; i --) {
                facv[i] = 1ll * facv[i + 1] * (i + 1) % mod;
            }
    
            c = norm(c);
            poly a(n + 1), b(n + 1);
            for (int i = 0; i <= n; i ++) {
                a[i] = 1ll * (*this)[i] * fact[i] % mod;
            }
            for (int i = 0, w = 1; i <= n; i ++, mul(w, c)) {
                b[i] = 1ll * w * facv[i] % mod;
            }
    
            poly res = a.mulT(b);
            for (int i = 0; i <= n; i ++) {
                mul(res[i], facv[i]);
            }
            return res;
        }
    
        // Chirp Z-Transform
        std::vector<int> czt(int c, int m) const {
            c = norm(c);
            if (c == 0) {
                std::vector<int> res(m, front());
                res[0] = 0;
                for (int x : *this) add(res[0], x);
                return res;
            }
    
            poly a = *this;
            int n = a.size(), ic = qpow(c, mod - 2, mod);
            poly b(n + m - 1), v(std::max(n, m));
            b[0] = 1;
            for (int i = 1, w = 1; i < b.size(); i ++, mul(w, c)) {
                b[i] = 1ll * b[i - 1] * w % mod;
            }
            v[0] = 1;
            for (int i = 1, w = 1; i < v.size(); i ++, mul(w, ic)) {
                v[i] = 1ll * v[i - 1] * w % mod;
            }
    
            for (int i = 0; i < n; i ++) {
                mul(a[i], v[i]);
            }
            poly res = b.mulT(a).modxk(m);
            for (int i = 0; i < m; i ++) {
                mul(res[i], v[i]);
            }
            return res;
        }
    };
    
    // 多项式快速插值
    poly lagrange(std::vector<std::pair<int, int>> seq) {
        int n = seq.size(); // seq 下标从 0 开始,至多 n-1 次多项式需要 n 个点值
        std::vector<poly> t(n * 4);
        std::vector<int> x(n);
        for (int i = 0; i < n; i ++) {
            x[i] = seq[i].first;
        }
    
        std::function<void(int, int, int)> build = [&] (int p, int l, int r) {
            if (l == r) {
                t[p] = poly{norm(-x[l]), 1};
                return;
            }
            int mid = (l + r) >> 1;
            build(p * 2, l, mid), build(p * 2 + 1, mid + 1, r);
            t[p] = t[p * 2] * t[p * 2 + 1];
        };
        build(1, 0, n - 1);
    
        auto res = (t[1].deriv()).eval(x);
        std::function<poly(int, int, int)> solve = [&] (int p, int l, int r) {
            if (l == r) {
                return poly{norm(1ll * seq[l].second * qpow(res[l], mod - 2, mod))};
            }
            int mid = (l + r) >> 1;
            return solve(p * 2, l, mid) * t[p * 2 + 1] + solve(p * 2 + 1, mid + 1, r) * t[p * 2];
        };
        return solve(1, 0, n - 1);
    }
    
    // 连续点值平移
    std::vector<int> shift_conti(std::vector<int> y, int c) {
        int n = y.size() - 1; // y 下标从 0 开始,连续点值为 f(0), ..., f(n)
        std::vector<int> fact(n + 1), facv(n + 1);
        fact[0] = 1;
        for (int i = 1; i <= n; i ++) {
            fact[i] = 1ll * fact[i - 1] * i % mod;
        }
        facv[n] = qpow(fact[n], mod - 2, mod);
        for (int i = n - 1; i >= 0; i --) {
            facv[i] = 1ll * facv[i + 1] * (i + 1) % mod;
        }
    
        poly a(2 * n + 1), b(n + 1);
        for (int i = 0; i <= 2 * n; i ++) {
            a[i] = qpow(norm(c - n + i), mod - 2, mod);
        }
        for (int i = 0; i <= n; i ++) {
            b[i] = 1ll * facv[i] * facv[n - i] % mod * norm(y[i]) % mod;
            if ((n - i) & 1) neg(b[i]);
        }
    
        poly res = a * b;
        int num = 1, z = 0;
        for (int i = c - n; i <= c; i ++) {
            int v = norm(i);
            if (v) mul(num, v); else z ++;
        }
        std::vector<int> ans(n + 1);
        for (int i = 0; i <= n; i ++) {
            ans[i] = z ? y[norm(c + i)] : 1ll * num * res[i + n] % mod;
            int v1 = norm(c - n + i), v2 = norm(c + i + 1);
            if (v1) mul(num, a[i]); else z --;
            if (v2) mul(num, v2); else z ++;
        }
        return ans;
    }

    Bostan-Mori

    分式远处系数

    分式远处系数:用于求解分式 P(x)Q(x)\frac{P(x)}{Q(x)} 的第 nn 项 [xn]P(x)Q(x)[x^n]\frac{P(x)}{Q(x)}。

    考虑

    P(x)Q(x)=P(x)Q(−x)Q(x)Q(−x)\frac{P(x)}{Q(x)} = \frac{P(x)Q(-x)}{Q(x)Q(-x)}

    由于 Q(x)Q(−x)Q(x)Q(-x) 是偶函数,仅偶次项有值。记 U(x2)=Q(x)Q(−x)U(x^2) = Q(x)Q(-x),然后将分子按照奇偶次项拆开

    P(x)Q(−x)=Ceven(x2)+xCodd(x2)P(x)Q(-x) = C_{\mathrm{even}}(x^2) + xC_{\mathrm{odd}}(x^2)

    于是

    P(x)Q(x)=Ceven(x2)U(x2)+xCodd(x2)U(x2)\frac{P(x)}{Q(x)} = \frac{C_{\mathrm{even}}(x^2)}{U(x^2)} + \frac{xC_{\mathrm{odd}}(x^2)}{U(x^2)}

    由于右式第一项只影响偶次项,右式第二项只影响奇次项。于是我们只需要根据 nn 的奇偶递归到其中一边即可。

    当 nn 为偶数时

    [xn]P(x)Q(x)=[xn2]Ceven(x)U(x)[x^n]\frac{P(x)}{Q(x)} = [x^\frac{n}{2}]\frac{C_{\mathrm{even}}(x)}{U(x)}

    当 nn 为奇数时

    [xn]P(x)Q(x)=[xn−12]Codd(x)U(x)[x^n]\frac{P(x)}{Q(x)} = [x^{\frac{n - 1}{2}}]\frac{C_{\mathrm{odd}}(x)}{U(x)}

    递归到 n=0n = 0 时,有 [x0]f(x)g(x)=f0g0[x^0]\frac{f(x)}{g(x)} = \frac{f_0}{g_0}。

    时间复杂度 O(mlog⁡mlog⁡n)\mathcal{O}(m \log m \log n),其中 mm 表示分子分母的长度。

    0x31 分式远处系数.cpp:

    // 分式远处系数
    int BostanMori(poly p, poly q, int n) {
        for (; n; n >>= 1) {
            poly nq = q;
            for (int i = 1; i < nq.size(); i += 2) {
                neg(nq[i]);
            }
            p *= nq, q *= nq;
    
            int i = n & 1;
            while (i < p.size()) {
                p[i / 2] = p[i], i += 2;
            }
            p.resize(i / 2);
    
            int j = 0;
            while (j < q.size()) {
                q[j / 2] = q[j], j += 2;
            }
            q.resize(j / 2);
        }
        return 1ll * p[0] * qpow(q[0], mod - 2, mod) % mod;
    }

    分式远处区间系数

    待填坑。

    常系数齐次线性递推

    常系数齐次线性递推:已知初值 a0,…,ak−1a_0, \dots, a_{k - 1} 与系数 c1,…,ckc_1, \dots, c_k(常数项 c0=0c_0 = 0),对于一个 kk 阶齐次线性递推数列 ai=∑j=1kcjai−ja_i = \sum_{j = 1}^k c_ja_{i - j},求出第 nn 项。

    Fiduccia 算法

    Fiduccia 算法:构造特征多项式 Γ(x)=xk−∑i=1kcixk−i\Gamma(x) = x^k - \sum_{i = 1}^{k}c_ix^{k - i},记 A(x)=∑i=0k−1aixiA(x) = \sum_{i = 0}^{k - 1} a_ix^i,则有

    an=(xn mod Γ(x))⋅A(x)a_n = \left(x^n \bmod \Gamma(x) \right) \cdot A(x)

    (其中 ⋅\cdot 代表点积)

    于是应用多项式快速幂(倍增法)求出 xn mod Γ(x)x^n \bmod \Gamma(x),最后求出点积即可。

    时间复杂度 O(klog⁡klog⁡n)\mathcal{O}(k \log k \log n)。

    该做法的优点是,当项数 nn 与递推系数 cc 固定时,可以做到 O(klog⁡klog⁡n)\mathcal{O}(k \log k \log n) 预处理,O(k)\mathcal{O}(k) 查询。

    Fiduccia 算法的简单解释:我们想要知道 ana_n 具体可以表示成怎样的 a0,…,ak−1a_0, \dots, a_{k - 1} 的线性组合。相当于是初始有一个 ana_n,每次选出最高项 aia_i,根据公式 ai=∑j=1kcjai−ja_i = \sum_{j = 1}^kc_ja_{i - j} 将 aia_i 消成更低的项。

    从生成函数的角度考虑,相当于是将 xix^i 替换成 ∑j=1kcjxi−j\sum_{j = 1}^kc_jx^{i - j},等价于减去 xi−k(xk−∑j=1kcjxk−j)x^{i - k}\left( x^k - \sum_{j = 1}^kc_jx^{k - j} \right)。整个过程等价于 xnx^n 对 xk−∑j=1kcjxk−jx^{k} - \sum_{j = 1}^k c_jx^{k - j} 取模。

    0x31 常系数齐次线性递推(Fiduccia).cpp:

    // 常系数齐次线性递推(Fiduccia)
    int linearRecurrence(std::vector<int> c, std::vector<int> y, int n) {
        int k = y.size(); // k 阶齐次线性递推数列
        if (n < k) return norm(y[n]);
    
        poly g(k + 1);
        g[k] = 1;
        for (int i = 1; i <= k; i ++) {
            g[k - i] = norm(-c[i]);
        }
    
        poly res{1}, a{0, 1};
        for (int b = n; b; b >>= 1) {
            if (b & 1) res = divmod(res * a, g).second;
            a = divmod(a * a, g).second;
        }
    
        int ans = 0;
        for (int i = 0; i < res.size(); i ++) {
            ans = (ans + 1ll * y[i] * res[i]) % mod;
        }
        return norm(ans);
    }

    递推式转分式

    对于 kk 阶齐次线性递推数列 {ai}\{a_i\},我们想要构造多项式 P(x),Q(x)P(x), Q(x) 使得 [xn]P(x)Q(x)=an[x^n]\frac{P(x)}{Q(x)} = a_n。构造如下

    Q(x)=1−∑i=1kcixiP(x)=((∑i=0k−1aixi)×Q(x)) mod xk\begin{gathered} Q(x) = 1 - \sum_{i = 1}^kc_ix^i \\ P(x) = \left(\left(\sum_{i = 0}^{k - 1} a_ix^i \right) \times Q(x)\right) \bmod{x^k} \end{gathered}

    检验:设 P(x)Q(x)=∑i=0∞hixi\frac{P(x)}{Q(x)} = \sum_{i = 0}^{\infty} h_ix^i。当 0≤i<k0 \leq i < k 时,根据定义有 hi=aih_i = a_i。当 i≥ki \geq k 时,化简得 hi=∑j=1kcjhi−jh_i = \sum_{j = 1}^k c_jh_{i - j},正是 {ai}\{a_i\} 的递推式。归纳得 hi=aih_i = a_i。

    于是构造多项式 P(x),Q(x)P(x), Q(x),套用 Bostan-Mori 求解 [xn]P(x)Q(x)[x^n]\frac{P(x)}{Q(x)} 即可。

    时间复杂度 O(klog⁡klog⁡n)\mathcal{O}(k \log k \log n),但单次询问常数相较于 Fiduccia 算法更小。

    0x31 常系数齐次线性递推(递推式转分式).cpp:

    // 常系数齐次线性递推(递推式转分式)
    int linearRecurrence(std::vector<int> c, std::vector<int> y, int n) {
        int k = y.size(); // k 阶齐次线性递推数列
        if (n < k) return norm(y[n]);
    
        for (int &x : c) x = norm(x);
        for (int &x : y) x = norm(x);
    
        poly q = poly{1} - poly(c);
        poly p = (poly(y) * q).modxk(k);
        return BostanMori(p, q, n);
    }

    整式递推

    应用:快速阶乘算法

    快速阶乘算法:求 n! mod pn! \bmod p,其中 pp 是一个大质数。

    (由于模数固定时可以分段打表,所以大概率不保证 pp 是一个 NTT 模数,此时需要使用 MTT)。

    设 v=⌊n⌋v = \left\lfloor \sqrt{n} \right\rfloor,设多项式 g(x)=∏i=1v(x+i)g(x) = \prod_{i = 1}^v (x + i),则

    n!=(∏i=0v−1g(iv))⋅(∏i=v2+1ni)n! = \left( \prod_{i = 0}^{v - 1}g(iv) \right) \cdot \left( \prod_{i = v^2 + 1}^n i \right)

    首先后半部分的 ∏i=v2+1ni\prod_{i = v^2 + 1}^n i 可以 O(n)\mathcal{O}(\sqrt{n}) 求出。我们现在只关心前半部分。

    设多项式 gd(x)=∏i=1d(x+i)g_d(x) = \prod_{i = 1}^d (x + i),则 d+1d + 1 个点值 gd(0),gd(v),…,gd(dv)g_d(0), g_d(v), \dots, g_d(dv) 可以唯一确定 dd 次多项式 gd(x)g_d(x)。所以对于当前的 dd,我们都需要维护出这 d+1d + 1 个点值。

    初始时 d=1d = 1,只有点值 g1(0)=1,g1(v)=v+1g_1(0) = 1, g_1(v) = v + 1。考虑两种操作:

    操作 1:d←2dd \gets 2d。

    • 补齐点值:补齐 gd((d+1)v),…,gd(2dv)g_d((d + 1)v), \dots, g_d(2dv),可以通过 gd(0),gd(v),…,gd(dv)g_d(0), g_d(v), \dots, g_d(dv) 向右平移 dvdv 得到(即连续点值 h(x)=gd(xv)h(x) = g_d(xv) 向右平移 dd)。
    • 修正点值:有公式 g2d(x)=gd(x)gd(x+d)g_{2d}(x) = g_d(x)g_d(x + d),将所有点值 gd(x)g_d(x) 向右平移 dd 得到 gd(x+d)g_d(x + d)(即连续点值 h(x)=gd(xv)h(x) = g_d(xv) 向右平移 dv\frac{d}{v}),然后对应位相乘即可。

    操作 2:d←d+1d \gets d + 1。

    • 修正点值:有公式 gd+1(x)=gd(x)⋅(x+d+1)g_{d + 1}(x) = g_d(x) \cdot (x + d + 1),直接相乘即可。
    • 补齐点值:补齐 gd+1((d+1)v)g_{d + 1}((d + 1)v),直接暴力 O(d)\mathcal{O}(d) 求出即可。

    于是可以从 d=1d = 1 通过倍增变换到 d=vd = v。倍增过程的时间复杂度为 T(v)=T(v2)+O(vlog⁡v)=O(vlog⁡v)T(v) = T(\frac{v}{2}) + \mathcal{O}(v \log v) = \mathcal{O}(v \log v)。

    而我们只需要 O(n)\mathcal{O}(\sqrt{n}) 个点值,故时间复杂度 O(nlog⁡n)\mathcal{O}(\sqrt{n} \log n)。

    0x31 快速阶乘算法.cpp:

    // 快速阶乘算法
    int fastFactorial(int n) {
        if (n == 0) return 1;
        if (n >= mod) return 0;
    
        int v = sqrt(n), iv = qpow(v, mod - 2, mod);
        std::function<std::vector<int>(int)> solve = [&] (int d) {
            if (d == 1) {
                return std::vector<int>{1, v + 1};
            }
            if (d & 1) {
                auto y = solve(d - 1);
                for (int i = 0; i < y.size(); i ++) {
                    mul(y[i], i * v + d);
                }
                int num = 1;
                for (int i = 1; i <= d; i ++) {
                    mul(num, d * v + i);
                }
                y.push_back(num);
                return y;
            } else {
                auto y = solve(d / 2);
                auto y1 = shift_conti(y, d / 2);
                y.insert(y.end(), y1.begin() + 1, y1.end());
                auto y2 = shift_conti(y, 1ll * (d / 2) * iv % mod);
                for (int i = 0; i < y.size(); i ++) {
                    mul(y[i], y2[i]);
                }
                return y;
            }
        };
    
        auto res = solve(v);
        int ans = 1;
        for (int i = 0; i < v; i ++) {
            mul(ans, res[i]);
        }
        for (int i = v * v + 1; i <= n; i ++) {
            mul(ans, i);
        }
        return ans;
    }

    多项式复合

    待填坑。

    拉格朗日反演

    待填坑。

    Power Projection

    Power Projection:给出多项式 A(x),B(x)A(x), B(x) 以及正整数 nn,保证 [x0]B(x)=0[x^0]B(x) = 0。求出

    [xn−1]A(x)B(x)i(0≤i<n)[x^{n - 1}]A(x)B(x)^i \quad (0 \leq i < n)

    0x31 Power Projection.cpp:

    // Power Projection
    poly PowerProjection(poly a, poly b, int n) {
        // assert(n >= 1);
        // assert(!b.size() || !b[0]);
    
        a.resize(n), b.resize(n);
        for (int &x : b) {
            neg(x);
        }
    
        int n0 = n --;
        for (int m = 1; n; m <<= 1, n >>= 1) {
            int L = n * 2 + 2, len = 1;
            while (len < 2 * m * L) len <<= 1;
    
            poly d(len);
            for (int i = 0; i < m; i ++) {
                for (int j = 0; j <= n; j ++) {
                    d[i * L + j] = b[i * (n + 1) + j];
                }
            }
            dft(d);
    
            int h = len >> 1;
            poly work(h);
            for (int i = 0; i < h; i ++) {
                work[i] = 1ll * d[i] * d[i + h] % mod;
                std::swap(d[i], d[i + h]);
            }
            idft(work);
    
            int t = n / 2 + 1;
            poly p(2 * m * t), q(2 * m * t);
            for (int i = 0; i < 2 * m - 1; i ++) {
                for (int j = 0; j < t; j ++) {
                    q[i * t + j] = work[i * (n + 1) + j];
                }
            }
            for (int i = 0; i < m; i ++) {
                for (int j = 0; j < t; j ++) {
                    add(q[(m + i) * t + j], b[i * (n + 1) + 2 * j]);
                    add(q[(m + i) * t + j], b[i * (n + 1) + 2 * j]);
                }
            }
    
            poly c(len);
            for (int i = 0; i < m; i ++) {
                for (int j = 0; j <= n; j ++) {
                    c[i * L + j] = a[i * (n + 1) + j];
                }
            }
            dft(c);
            for (int i = 0; i < len; i ++) {
                mul(c[i], d[i]);
            }
            idft(c);
    
            for (int i = 0; i < 2 * m - 1; i ++) {
                for (int j = 0; j < t; j ++) {
                    p[i * t + j] = c[i * L + 2 * j + (n & 1)];
                }
            }
            for (int i = 0; i < m; i ++) {
                for (int j = 0; j < t; j ++) {
                    add(p[(m + i) * t + j], a[i * (n + 1) + 2 * j + (n & 1)]);
                }
            }
            a.swap(p), b.swap(q);
        }
    
        std::reverse(a.begin(), a.end());
        a.resize(n0);
        return a;
    }

    多项式复合逆

    待填坑。

    0x32 数学 集合幂级数

    FWT

    位运算卷积:已知序列 a0,…,a2m−1a_0, \dots, a_{2^m - 1} 和序列 b0,…,b2m−1b_0, \dots, b_{2^m - 1},求出 c0,…,c2m−1c_0, \dots, c_{2^m - 1},其中

    ck=∑i⊕j=kaibjc_k = \sum_{i \oplus j = k} a_ib_j

    其中 ⊕\oplus 表示一种位运算(or / and / xor)。

    DWT

    FFT 多项式乘法的核心思想:A,BA, B 的系数转 A,BA, B 的点值,A,BA, B 的点值点积转 CC 的点值,CC 的点值转 CC 的系数。

    我们想要 DWT 与 IDWT 有着类似的功能。设 dwt(a)\mathrm{dwt}(a) 表示幂级数 aa 经过 DWT 变换后得到的幂级数(点值),我们希望

    a×b=c  ⟺  dwt(a)⋅dwt(b)=dwt(c)a \times b = c \iff \mathrm{dwt}(a) \cdot \mathrm{dwt}(b) = \mathrm{dwt}(c)

    由于 DFT 是线性变换,我们希望 DWT 也是线性变换。

    记序列长度 n=2mn = 2^m,设 dwt(a)i=∑j=0n−1c(i,j)aj\mathrm{dwt}(a)_i = \sum_{j = 0}^{n - 1} c(i, j)a_j,其中变换系数 c(i,j)c(i, j) 表示变换前下标 jj 对变换后下标 ii 的贡献。

    由 dwt(a)⋅dwt(b)=dwt(c)\mathrm{dwt}(a) \cdot \mathrm{dwt}(b) = \mathrm{dwt}(c),得

    dwt(c)i=dwt(a)i⋅dwt(b)i(∑p=0n−1c(i,p)cp)=(∑j=0n−1c(i,j)aj)⋅(∑k=0n−1c(i,k)bk)∑p=0n−1c(i,p)cp=∑j=0n−1∑k=0n−1c(i,j)c(i,k)ajbk\begin{gathered} \mathrm{dwt}(c)_i = \mathrm{dwt}(a)_i \cdot \mathrm{dwt}(b)_i \\ \left( \sum_{p = 0}^{n - 1}c(i, p)c_p \right) = \left( \sum_{j = 0}^{n - 1}c(i, j)a_j \right) \cdot \left( \sum_{k = 0}^{n - 1}c(i, k)b_k \right) \\ \sum_{p = 0}^{n - 1}c(i, p)c_p = \sum_{j = 0}^{n - 1}\sum_{k = 0}^{n - 1}c(i, j)c(i, k)a_jb_k \end{gathered}

    由 a×b=ca \times b = c,得

    ∑p=0n−1c(i,p)cp=∑p=0n−1c(i,p)∑t1⊕t2=pat1bt2=∑p=0n−1∑t1⊕t2=pc(i,t1⊕t2)at1bt2=∑t1=0n−1∑t2=0n−1c(i,t1⊕t2)at1bt2\begin{aligned} \sum_{p = 0}^{n - 1} c(i, p)c_p & = \sum_{p = 0}^{n - 1} c(i, p) \sum_{t_1 \oplus t_2 = p} a_{t_1}b_{t_2} \\ & = \sum_{p = 0}^{n - 1} \sum_{t_1 \oplus t_2 = p} c(i, t_1 \oplus t_2) a_{t_1}b_{t_2} \\ & = \sum_{t_1 = 0}^{n - 1} \sum_{t_2 = 0}^{n - 1} c(i, t_1 \oplus t_2) a_{t_1}b_{t_2} \end{aligned}

    对比上下两段的最后一个式子,发现充要条件为 c(i,j)c(i,k)=c(i,j⊕k)c(i, j)c(i, k) = c(i, j \oplus k)。

    由于位运算可以按位考虑,可以这样构造 c(i,j)c(i, j):先得到单个二进制位的转移系数 c([0,1],[0,1])c([0, 1], [0, 1]),满足 c(i,j)c(i,k)=c(i,j⊕k)c(i, j)c(i, k) = c(i, j \oplus k)。对于所有的 c(i,j)c(i, j),我们将 i,ji, j 二进制分解,将对应位的转移系数相乘

    c(i,j)=∏x=0m−1c(ix,jx)c(i, j) = \prod_{x = 0}^{m - 1} c(i_x, j_x)

    (其中 ix,jxi_x, j_x 分别表示 i,ji, j 的二进制下第 xx 位)

    代入条件 c(i,j)c(i,k)=c(i,j⊕k)c(i, j)c(i, k) = c(i, j \oplus k),可验证其成立

    c(i,j)c(i,k)=(∏x=0m−1c(ix,jx))(∏x=0m−1c(ix,kx))=∏x=0m−1c(ix,jx)c(ix,kx)=∏x=0m−1c(ix,jx⊕kx)=c(i,j⊕k)\begin{aligned} c(i, j)c(i, k) & = \left(\prod_{x = 0}^{m - 1}c(i_x, j_x)\right) \left( \prod_{x = 0}^{m - 1}c(i_x, k_x) \right) \\ & = \prod_{x = 0}^{m - 1} c(i_x, j_x)c(i_x, k_x) \\ & = \prod_{x = 0}^{m - 1} c(i_x, j_x \oplus k_x) \\ & = c(i, j \oplus k) \end{aligned}

    现在考虑优化计算 DWT。考虑按最高位拆分,记 i′,j′i', j' 表示 i,ji, j 去掉最高位的值,记 ihi_h 表示 ii 的最高位

    dwt(a)i=∑j=0n−1c(i,j)aj=∑j=0n/2−1c(i,j)aj+∑j=n/2n−1c(i,j)aj=c(ih,0)(∑j=0n/2−1c(i′,j′)aj)+c(ih,1)(∑j=n/2n−1c(i′,j′)aj)\begin{aligned} \mathrm{dwt}(a)_i & = \sum_{j = 0}^{n - 1}c(i, j)a_j \\ & = \sum_{j = 0}^{n / 2 - 1}c(i, j)a_j + \sum_{j = n / 2}^{n - 1}c(i, j)a_j \\ & = c(i_h, 0) \left( \sum_{j = 0}^{n / 2 - 1}c(i', j')a_j \right) + c(i_h, 1)\left( \sum_{j = n / 2}^{n - 1}c(i', j')a_j \right) \end{aligned}

    发现括号里的式子是一个子问题。记 a0a_0 表示幂级数 aa 最高位为 00 的部分,a1a_1 表示幂级数 aa 最高位为 11 的部分。

    • 对于 k<n/2k < n / 2,代入 i=ki = k 得

      dwt(a)k=c(0,0)⋅dwt(a0)k+c(0,1)⋅dwt(a1)k\mathrm{dwt}(a)_k = c(0, 0) \cdot \mathrm{dwt}(a_0)_k + c(0, 1) \cdot \mathrm{dwt}(a_1)_k
    • 对于 k<n/2k < n / 2,代入 i=k+n/2i = k + n / 2 得

      dwt(a)k+n/2=c(1,0)⋅dwt(a0)k+c(1,1)⋅dwt(a1)k\mathrm{dwt}(a)_{k + n / 2} = c(1, 0) \cdot \mathrm{dwt}(a_0)_k + c(1, 1) \cdot \mathrm{dwt}(a_1)_k

    如果我们知道 dwt(a0)i,dwt(a1)i\mathrm{dwt}(a_0)_i, \mathrm{dwt}(a_1)_i 在 i=0,1,…,n/2−1i = 0, 1, \dots, n / 2 - 1 处的值,就可以 O(n)\mathcal{O}(n) 求出 dwt(a)i\mathrm{dwt}(a)_i 在 i=0,1,…,n−1i = 0, 1, \dots, n - 1 处的值。

    这是一个分治的过程,不断分治直到仅剩一个项即可。

    时间复杂度 O(m2m)\mathcal{O}(m2^m)。

    IDWT

    在 DWT 中,我们只需要

    c=[c(0,0)c(0,1)c(1,0)c(1,1)]c = \begin{bmatrix} c(0, 0) & c(0, 1) \\ c(1, 0) & c(1, 1) \end{bmatrix}

    这四个数即可完成变换,记该矩阵为位矩阵 cc。

    如果我们要进行 IDWT,则需要位矩阵 cc 的逆矩阵 c−1c^{-1}。类似地,有

    ai=∑j=0n−1c−1(i,j)dwt(a)ja_i = \sum_{j = 0}^{n - 1} c^{-1}(i, j)\mathrm{dwt}(a)_j

    套用 DWT 的模板即可。

    在构造矩阵 cc 的时候,我们需要小心一点,得确保矩阵 cc 存在逆矩阵 c−1c^{-1}。

    位运算卷积

    or 卷积:or 运算的位矩阵,及其逆矩阵

    c=[1011],c−1=[10−11]c = \begin{bmatrix} 1 & 0 \\ 1 & 1 \end{bmatrix}, \quad c^{-1} = \begin{bmatrix} 1 & 0 \\ -1 & 1 \end{bmatrix}

    or 卷积的正变换等价于子集求和,因为 c(i,j)=[iand⁡j=j]c(i, j) = [i \operatorname{and} j = j]。

    and 卷积:and 运算的位矩阵,及其逆矩阵

    c=[1101],c−1=[1−101]c = \begin{bmatrix} 1 & 1 \\ 0 & 1 \end{bmatrix}, \quad c^{-1} = \begin{bmatrix} 1 & -1 \\ 0 & 1 \end{bmatrix}

    and 卷积的正变换等价于超集求和,因为 c(i,j)=[ior⁡j=j]c(i, j) = [i \operatorname{or} j = j]。

    xor 卷积:xor 运算的位矩阵,及其逆矩阵

    c=[111−1],c−1=12[111−1]c = \begin{bmatrix} 1 & 1 \\ 1 & -1 \end{bmatrix}, \quad c^{-1} = \frac{1}{2}\begin{bmatrix} 1 & 1 \\ 1 & -1 \end{bmatrix}

    xor 卷积的正变换,其变换系数 c(i,j)=(−1)popcount(iand⁡j)c(i, j) = (-1)^{\mathrm{popcount}(i \operatorname{and} j)}。

    xor 卷积的 IDWT 相较于 DWT,每一位的变换系数需要乘以 12\frac{1}{2},一共有 mm 位,总共的影响为 12m=1n\frac{1}{2^m} = \frac{1}{n}。所以 xor 卷积的 IDWT 只需套用 DWT 的模板,最后乘以 1n\frac{1}{n} 即可。

    0x32 FWT.cpp:

    void dwtOr(std::vector<int> &a, int opt) {
        int n = a.size();
        for (int k = 1; k < n; k <<= 1) {
            for (int i = 0; i < n; i += (k << 1)) {
                for (int j = 0; j < k; j ++) {
                    opt > 0 ? add(a[i + j + k], a[i + j]) : dec(a[i + j + k], a[i + j]);
                }
            }
        }
    }
    void dwtAnd(std::vector<int> &a, int opt) {
        int n = a.size();
        for (int k = 1; k < n; k <<= 1) {
            for (int i = 0; i < n; i += (k << 1)) {
                for (int j = 0; j < k; j ++) {
                    opt > 0 ? add(a[i + j], a[i + j + k]) : dec(a[i + j], a[i + j + k]);
                }
            }
        }
    }
    void dwtXor(std::vector<int> &a, int opt) {
        int n = a.size();
        for (int k = 1; k < n; k <<= 1) {
            for (int i = 0; i < n; i += (k << 1)) {
                for (int j = 0; j < k; j ++) {
                    int u = a[i + j], v = a[i + j + k];
                    add(a[i + j] = u, v), dec(a[i + j + k] = u, v);
                }
            }
        }
        if (opt < 0) {
            int inv = qpow(n, mod - 2, mod);
            for (int i = 0; i < n; i ++) {
                mul(a[i], inv);
            }
        }
    }
    
    // 位运算卷积
    using dwtFunc = void(*)(std::vector<int>&, int);
    std::vector<int> conv(std::vector<int> a, std::vector<int> b, dwtFunc dwt) {
        dwt(a, +1), dwt(b, +1);
        for (int i = 0; i < a.size(); i ++) {
            mul(a[i], b[i]);
        }
        dwt(a, -1);
        return a;
    }

    子集 dp

    子集 dp:已知序列 a0,…,a2m−1a_0, \dots, a_{2^m - 1},求出 b0,…,b2m−1b_0, \dots, b_{2^m - 1},其中 bi=∑j⊆iajb_i = \sum_{j \subseteq i} a_j。

    将一个二进制状态视作一个 mm 维的坐标,第 ii 维的取值等于二进制下第 ii 位的值。则二进制下的子集和,相当于是要求每个维度都小于等于当前坐标的所有坐标的权值和,运用高维前缀和即可。

    当信息满足可减性时,可以进行子集 dp 的逆过程。

    时间复杂度 O(m2m)\mathcal{O}(m2^m)。

    // 注意:要先枚举维度 i,再枚举状态 S
    for (int i = 0; i < m; i ++) {
        for (int S = 0; S < (1 << m); S ++) {
            if (S >> i & 1) {
                f[S] += f[S ^ (1 << i)];
            }
        }
    }

    半在线子集 dp:求出 b0,…,b2m−1b_0, \dots, b_{2^m - 1},其中 bib_i 与 ∑j⊊ibj\sum_{j \subsetneq i} b_j 强相关。

    按照 ∣S∣|S| 从小到大分层计算。每一层都做一次子集 dp,然后更新当前层的所有状态。

    时间复杂度 O(m22m)\mathcal{O}(m^22^m)。

    for (int s = 1; s <= m; s ++) {
        for (int S = 0; S < (1 << m); S ++) {
            tmp[S] = f[S];
        }
        for (int i = 0; i < m; i ++) {
            for (int S = 0; S < (1 << m); S ++) {
                if (S >> i & 1) {
                    tmp[S] += tmp[S ^ (1 << i)];
                }
            }
        }
        
        for (int S = 0; S < (1 << m); S ++) {
            if (__builtin_popcount(S) == s) {
                // 使用 tmp[S] 更新 f[S]
            }
        }
    }

    子集卷积

    子集卷积:已知序列 a0,…,a2m−1a_0, \dots, a_{2^m - 1} 和序列 b0,…,b2m−1b_0, \dots, b_{2^m - 1},求出 c0,…,c2m−1c_0, \dots, c_{2^m - 1},其中

    ck=∑ior⁡j=k,iand⁡j=∅aibjc_k = \sum_{i \operatorname{or} j = k, i \operatorname{and} j = \varnothing} a_ib_j

    注意到 iand⁡j=∅i \operatorname{and} j = \varnothing 的充要条件为 ∣i∣+∣j∣=∣ior⁡j∣|i| + |j| = |i \operatorname{or} j|。于是引入序列 ff 的占位多项式 FF

    Fp,i={fi∣i∣=p0∣i∣≠pF_{p, i} = \begin{cases} f_i & |i| = p\\ 0 & |i| \neq p \end{cases}

    将占位多项式代入到子集卷积的式子中

    Cs,k=∑p+q=s∑ior⁡j=kAp,iBq,jC_{s, k} = \sum_{p + q = s} \sum_{i \operatorname{or} j = k}A_{p, i}B_{q, j}

    从 or 卷积的角度来看,有

    Cs=∑p+q=sApor⁡BqC_s = \sum_{p + q = s}A_p \operatorname{or} B_q

    于是将 ApA_p 和 BqB_q 进行 DWT,求出所有的 CsC_s 后再进行 IDWT 即可。

    时间复杂度 O(m22m)\mathcal{O}(m^22^m),空间复杂度 O(m2m)\mathcal{O}(m2^m)。

    0x32 子集卷积.cpp:

    // 子集卷积
    std::vector<int> subset_conv(std::vector<int> a, std::vector<int> b) {
        int n = a.size(), m = std::__lg(n);
        std::vector<std::vector<int>> A(m + 1, std::vector<int>(n, 0));
        std::vector<std::vector<int>> B(m + 1, std::vector<int>(n, 0));
        std::vector<std::vector<int>> C(m + 1, std::vector<int>(n, 0));
        
        for (int i = 0; i < n; i ++) {
            int s = __builtin_popcount(i);
            A[s][i] = a[i], B[s][i] = b[i];
        }
        for (int i = 0; i <= m; i ++) {
            dwtOr(A[i], +1), dwtOr(B[i], +1);
        }
        for (int i = 0; i <= m; i ++) {
            for (int j = 0; j <= i; j ++) {
                for (int k = 0; k < n; k ++) {
                    add(C[i][k], 1ll * A[j][k] * B[i - j][k] % mod);
                }
            }
        }
        for (int i = 0; i <= m; i ++) {
            dwtOr(C[i], -1);
        }
    
        std::vector<int> c(n);
        for (int i = 0; i < n; i ++) {
            c[i] = C[__builtin_popcount(i)][i];
        }
        return c;
    }

    半在线子集卷积:已知序列 g0,…,g2m−1g_0, \dots, g_{2^m - 1},求出 f0,…,f2m−1f_0, \dots, f_{2^m - 1},其中对于 k>0k > 0 满足

    fk=∑ior⁡j=k,iand⁡j=∅figjf_k = \sum_{i \operatorname{or} j = k, i \operatorname{and} j = \varnothing} f_ig_j

    先根据具体问题的定义得出 f0f_0(g0g_0 一般来说等于 00)。

    然后按照 ∣S∣|S| 从小到大分层计算,每一层都根据前面层的 DWT 结果得到当前层的 DWT 结果,然后先 IDWT 回去,更新当前层的所有状态,然后再 DWT 回来,为后面层的计算做准备。

    时间复杂度 O(m22m)\mathcal{O}(m^22^m),空间复杂度 O(m2m)\mathcal{O}(m2^m)。

    0x32 半在线子集卷积.cpp:

    // 半在线子集卷积
    std::vector<int> subset_conv(std::vector<int> g) {
        int n = g.size(), m = std::__lg(n);
        std::vector<std::vector<int>> F(m + 1, std::vector<int>(n, 0));
        std::vector<std::vector<int>> G(m + 1, std::vector<int>(n, 0));
    
        for (int i = 1; i < n; i ++) { // 一般来说 g_0 = 0,所以不考虑 G[0]
            G[__builtin_popcount(i)][i] = g[i];
        }
        for (int i = 1; i <= m; i ++) {
            dwtOr(G[i], +1);
        }
    
        int f0 = 1;
        std::fill(F[0].begin(), F[0].end(), f0); // 一般来说 f_0 = 1,这一步模拟了 dwtOr(F[0], +1)
    
        std::vector<int> f(n);
        f[0] = f0;
        for (int i = 1; i <= m; i ++) {
            for (int j = 1; j <= i; j ++) {
                for (int k = 0; k < n; k ++) {
                    add(F[i][k], 1ll * G[j][k] * F[i - j][k] % mod);
                }
            }
            dwtOr(F[i], -1);
    
            for (int S = 0; S < n; S ++) {
                if (__builtin_popcount(S) == i) {
                    // 在此更新 F[i][S],即为真正的 f[S]
                    f[S] = F[i][S];
                } else {
                    F[i][S] = 0;
                }
            }
            dwtOr(F[i], +1);
        }
        return f;
    }

    0x33 数学 组合计数

    排列组合

    排列数:AnmA_{n}^m,从 nn 个有标号元素中,取出 mm 个元素排成一列的方案数(需要考虑取数顺序)。

    Anm=n!(n−m)!=nm‾A_n^m = \frac{n!}{(n - m)!} = n^{\underline{m}}

    组合数:CnmC_n^m 或 (nm)\binom{n}{m},从 nn 个有标号元素中,取出 mm 个元素组成集合的方案数(不需要考虑取数顺序)。

    (nm)={nm‾m!m∈Z,m≥00m∈Z,m<0\binom{n}{m} = \begin{cases} \frac{n^{\underline{m}}}{m!} & m \in \mathbb{Z}, m \geq 0 \\ 0 & m \in \mathbb{Z}, m < 0 \end{cases}

    组合数常见恒等式

    阶乘展开式:n,m∈Zn, m \in \mathbb{Z},n≥m≥0n \geq m \geq 0

    (nm)=n!m!(n−m)!\binom{n}{m} = \frac{n!}{m!(n - m)!}

    归纳恒等式:m∈Zm \in \mathbb{Z}

    (nm)=(n−1m)+(n−1m−1)\binom{n}{m} = \binom{n - 1}{m} + \binom{n - 1}{m - 1}

    对称恒等式:n,m∈Zn, m \in \mathbb{Z},n≥0n \geq 0

    (nm)=(nn−m)\binom{n}{m} = \binom{n}{n - m}

    吸收恒等式:m∈Zm \in \mathbb{Z}

    (nm)=nm(n−1m−1)(m≠0)(nm)=nn−m(n−1m)(n≠m)\begin{aligned} \binom{n}{m} & = \frac{n}{m}\binom{n - 1}{m - 1} \qquad (m \neq 0) \\ \binom{n}{m} & = \frac{n}{n - m}\binom{n - 1}{m} \qquad (n \neq m) \end{aligned}

    上指标反转:m∈Zm \in \mathbb{Z}

    (nm)=(−1)m(m−n−1m)\binom{n}{m} = (-1)^m \binom{m - n - 1}{m}

    三项式版恒等式:m,k∈Zm, k \in \mathbb{Z}

    (nm)(mk)=(nk)(n−km−k)\binom{n}{m}\binom{m}{k} = \binom{n}{k}\binom{n - k}{m - k}

    二项式定理:n∈Nn \in \mathbb{N}

    (x+y)n=∑i=0n(ni)xiyn−i(x + y)^n = \sum_{i = 0}^n \binom{n}{i}x^{i}y^{n - i}

    一些常见特例:

    • x=1x = 1 且 y=ay = a:
      ∑i=0n(ni)ai=(1+a)n\sum_{i = 0}^{n} \binom{n}{i}a^i = (1 + a)^n
    • x=1x = 1 且 y=−1y = -1:
      ∑i=0n(−1)i(ni)=[n=0]\sum_{i = 0}^n (-1)^i \binom{n}{i} = [n = 0]

    广义二项式定理:r∈Rr \in \mathbb{R},y>0y > 0,∣x∣<y|x| < y

    (x+y)r=∑k=0∞rk‾k!xkyr−k(x + y)^r = \sum_{k = 0}^{\infty} \frac{r^{\underline{k}}}{k!} x^{k}y^{r - k}

    平行求和法:m∈Zm \in \mathbb{Z}

    ∑0≤k≤m(n+kk)=(n+m+1m)\sum_{0 \leq k \leq m} \binom{n + k}{k} = \binom{n + m + 1}{m}

    上指标求和法:n,m∈Zn, m \in \mathbb{Z},n,m≥0n, m \geq 0

    ∑0≤k≤n(km)=(n+1m+1)\sum_{0 \leq k \leq n}\binom{k}{m} = \binom{n + 1}{m + 1}

    范德蒙德卷积:m∈Zm \in \mathbb{Z}

    ∑k(sk)(tm−k)=(s+tm)\sum_k \binom{s}{k}\binom{t}{m - k} = \binom{s + t}{m}

    范德蒙德卷积变式:m,s,t∈Nm, s, t \in \mathbb{N}

    ∑0≤k≤m(ks)(m−kt)=(m+1s+t+1)\sum_{0 \leq k \leq m} \binom{k}{s}\binom{m - k}{t} = \binom{m + 1}{s + t + 1}

    斜对角线求和法:n∈Nn \in \mathbb{N}

    ∑i=0n(n−ii)=Fibn+1\sum_{i = 0}^n \binom{n - i}{i} = \mathrm{Fib}_{n + 1}

    等价于长度为 n−1n - 1 的没有相邻 11 的二进制串个数。

    组合数带权和:n∈Nn \in \mathbb{N}

    ∑i=0ni(ni)=n2n−1\sum_{i = 0}^n i\binom{n}{i} = n2^{n - 1}

    组合数带权平方和:n∈Nn \in \mathbb{N}

    ∑i=0ni2(ni)=n(n+1)2n−2\sum_{i = 0}^n i^2\binom{n}{i} = n(n + 1)2^{n - 2}

    插板法

    问题 1:将 nn 个完全相同的元素分成 kk 组,保证每组至少有一个元素。等价于 ∑i=1kxi=n\sum_{i = 1}^k x_i = n 且 ∀xi≥1\forall x_i \geq 1 的整数解个数。

    相当于将 k−1k - 1 块板,插入 n−1n - 1 个间隙中。

    (n−1k−1)\binom{n - 1}{k - 1}

    问题 2:将 nn 个完全相同的元素分成 kk 组,允许组内元素为空。等价于 ∑i=1kxi=n\sum_{i = 1}^k x_i = n 且 ∀xi≥0\forall x_i \geq 0 的整数解个数。

    给 kk 组分别补一个元素,转化为问题 1。

    (n+k−1k−1)\binom{n + k - 1}{k - 1}

    问题 3:将 nn 个完全相同的元素分成 kk 组,保证第 ii 组至少分到 aia_i 个元素。

    给第 ii 组提前安排 aia_i 个元素,转化为问题 2。

    (n−∑ai+k−1k−1)\binom{n - \sum a_i + k - 1}{k - 1}

    Lucas 定理

    Lucas 定理:对于质数 pp

    (nm)≡(⌊n/p⌋⌊m/p⌋)(n mod pm mod p)(modp)\binom{n}{m} \equiv \binom{\lfloor n / p \rfloor}{\lfloor m / p \rfloor}\binom{n \bmod p}{m \bmod p} \pmod p

    相当于是将 n,mn, m 转化为 pp 进制,将每一位上对应的组合数 (nimi)\binom{n_i}{m_i} 相乘后对 pp 取模。

    组合数 mod 2:当 p=2p = 2 时,(nm)≡(⌊n/2⌋⌊m/2⌋)(n mod 2m mod 2)(mod2)\binom{n}{m} \equiv \binom{\lfloor n / 2 \rfloor}{\lfloor m / 2 \rfloor}\binom{n \bmod 2}{m \bmod 2} \pmod 2。

    故 (nm) mod 2=1\binom{n}{m} \bmod 2 = 1,当且仅当在二进制下 mm 是 nn 的子集。

    组合数常见求法

    求法 1:递推

    适用情况:对模数不做要求,可以承受平方时间的预处理(n≤5000n \leq 5000)。

    时间复杂度:预处理 O(n2)\mathcal{O}(n^2),查询 O(1)\mathcal{O}(1)。

    初值 (n0)=(nn)=1\binom{n}{0} = \binom{n}{n} = 1,递推式 (nm)=(n−1m)+(n−1m−1)\binom{n}{m} = \binom{n - 1}{m} + \binom{n - 1}{m - 1}。

    for (int i = 0; i <= n; i ++) {
        C[i][0] = C[i][i] = 1;
        for (int j = 1; j < i; j ++) {
            C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
        }
    }

    求法 2:预处理阶乘与阶乘逆元

    适用情况:要求模数为质数,可以承受线性时间的预处理(n≤106n \leq 10^6)。

    时间复杂度:预处理 O(n)\mathcal{O}(n),查询 O(1)\mathcal{O}(1)。

    将组合数使用阶乘形式表达

    (nm)=n!m!(n−m)!\binom{n}{m} = \frac{n!}{m!(n - m)!}

    考虑预处理出阶乘与阶乘逆元。

    设 facti=i!\mathrm{fact}_i = i!,则有初值 fact0=1\mathrm{fact}_0 = 1,递推式 facti=facti−1×i\mathrm{fact}_i =\mathrm{fact}_{i - 1} \times i。

    设 facvi=1i!\mathrm{facv}_i = \frac{1}{i!},则有初值 facvn=factn−1\mathrm{facv}_n = \mathrm{fact}_n^{-1},递推式 facvi=facvi+1×(i+1)\mathrm{facv}_i = \mathrm{facv}_{i + 1} \times(i + 1)。

    于是先正着递推一遍得到 fact0,…,n\mathrm{fact}_{0, \dots, n},然后通过一次求逆元得到 facvn\mathrm{facv}_n,最后再反着递推一遍得到 facvn,…,0\mathrm{facv}_{n, \dots, 0}。

    0x33 组合数(预处理阶乘与阶乘逆元).cpp:

    // 组合数(预处理阶乘与阶乘逆元)
    struct BinomCoef {
        std::vector<int> fact, facv;
    
        BinomCoef() {}
        BinomCoef(int n) {
            init(n);
        }
    
        void init(int n) {
            fact.resize(n + 1), facv.resize(n + 1);
            fact[0] = 1;
            for (int i = 1; i <= n; i ++) {
                fact[i] = 1ll * fact[i - 1] * i % mod;
            }
            facv[n] = qpow(fact[n], mod - 2, mod);
            for (int i = n - 1; i >= 0; i --) {
                facv[i] = 1ll * facv[i + 1] * (i + 1) % mod;
            }
        }
    
        int binom(int n, int m) {
            if (n < m || m < 0) {
                return 0;
            }
            return 1ll * facv[m] * facv[n - m] % mod * fact[n] % mod;
        }
        int perm(int n, int m) {
            if (n < m || m < 0) {
                return 0;
            }
            return 1ll * fact[n] * facv[n - m] % mod;
        }
    } bc;

    求法 3:暴力统计

    适用范围:要求模数为质数,mm 的范围可以承受线性枚举。

    时间复杂度:无预处理,查询 O(m)\mathcal{O}(m)。

    将组合数表达为

    (nm)=nm‾m!\binom{n}{m} = \frac{n^{\underline{m}}}{m!}

    注意到分子分母均只有 mm 项,当 nn 很大但 mm 很小时,可以暴力枚举。

    具体实现时,可以先分别求出分子与分母,然后再对分母求一次逆元。

    求法 4:Lucas 定理

    适用范围:要求模数为质数,模数以内的组合数可以预处理。

    时间复杂度:预处理 O(p)\mathcal{O}(p),查询 O(log⁡pn)\mathcal{O}(\log_{p} n)。

    由 Lucas 定理,得

    (nm)≡(⌊n/p⌋⌊m/p⌋)(n mod pm mod p)(modp)\binom{n}{m} \equiv \binom{\lfloor n / p \rfloor}{\lfloor m / p \rfloor}\binom{n \bmod p}{m \bmod p} \pmod p

    先预处理出模数以内的组合数。然后不断地使用 Lucas 定理,直到 n,mn, m 递降至模数以内。

    求法 5:exLucas 定理

    待填坑。

    求法 6:分段打表

    适用范围:要求模数为固定质数,代码长度限制不小,可以承受段长 O(W)\mathcal{O}(W) 时间的查询。

    (正常数据范围 n≤109n \leq 10^9,配合 Lucas 定理可以做到 mod≤109\mathrm{mod} \leq 10^9 且 n≤1018n \leq 10^{18})

    时间复杂度:打表预处理,查询 O(W)\mathcal{O}(W)。

    仍然将组合数使用阶乘形式表达,每次查询相当于要得到三个阶乘的值。

    考虑分段打表。记段长为 WW(取 105∼10610^5 \sim 10^6 相对合适),先通过打表预处理出所有 WW 的倍数的阶乘。

    每次查询 n!n! 的时候,就找到最近的 WW 的倍数,根据该答案继续向上乘。

    邪修:快速阶乘算法

    适用范围:要求模数为不固定质数(n≤109n \leq 10^9)。

    时间复杂度:无预处理,查询 O(nlog⁡n)\mathcal{O}(\sqrt{n} \log n)。

    直接使用快速阶乘算法!得到三个阶乘的值。

    求法 7:阶乘分解质因数

    适用范围 1:对模数不做要求,可以承受线性时间的查询(n≤106n \leq 10^6)。

    时间复杂度:预处理 O(n)\mathcal{O}(n),查询 O(n)\mathcal{O}(n)。

    适用范围 2:高精度组合数(n≤5000n \leq 5000)。

    仍然将组合数使用阶乘形式表达,我们考虑 1∼n1 \sim n 中的每个质数出现的次数。

    先将 1∼n1 \sim n 中所有的质数提前筛出来,大约有 nln⁡n\frac{n}{\ln n} 个质数。对于质数 pp,在阶乘 n!n! 中 pp 的出现次数为

    ∑i=1⌊log⁡pn⌋⌊npi⌋\sum_{i = 1}^{\lfloor \log_p n \rfloor} \left\lfloor \frac{n}{p^i} \right\rfloor

    于是将三个阶乘都进行质因数分解,得出每个质数的出现次数,然后将所有质数的贡献相乘即可。

    时间复杂度 O(n)\mathcal{O}(n)(高精度组合数的复杂度另算)。

    斯特林数

    第一类斯特林数

    待填坑。

    第二类斯特林数

    待填坑。

    卡特兰数

    卡特兰数:Catn\mathrm{Cat}_n,从原点 (0,0)(0, 0) 出发,每次只能向 xx 轴或 yy 轴正方向走,且不能越过直线 y=xy = x,到达 (n,n)(n, n) 的方案数。

    下标从 00 开始的若干项:

    1,1,2,5,14,42,132,429,1430,…1, 1, 2, 5, 14, 42, 132, 429, 1430, \dots

    卡特兰数通项公式:

    Catn=(2nn)−(2nn−1)=(2nn)n+1\begin{aligned} \mathrm{Cat}_n & = \binom{2n}{n} - \binom{2n}{n - 1} \\ & = \frac{\binom{2n}{n}}{n + 1} \end{aligned}

    简单推导:越过直线 y=xy = x,相当于是触碰直线 y=x+1y = x + 1。

    将触碰 y=x+1y = x + 1 的第一个点以后的路径,关于 y=x+1y = x + 1 对称,就可以得到一条从 (0,0)(0, 0) 到 (n−1,n+1)(n - 1, n + 1) 的路径。

    于是「(0,0)→(n,n)(0, 0) \to (n, n) 且越过 y=xy = x 的路径」与「(0,0)→(n−1,n+1)(0, 0) \to (n - 1, n + 1) 的路径」是一一对应的,方案数均为 (2nn−1)\binom{2n}{n - 1}。

    正难则反,不越过直线 y=xy = x 的方案数,即为总方案数 (2nn)\binom{2n}{n} 减去越过直线的方案数 (2nn−1)\binom{2n}{n - 1}。

    卡特兰数递推公式:

    Cat0=1Catn=∑i=0n−1CatiCatn−i−1\begin{gathered} \mathrm{Cat}_0 = 1 \\ \mathrm{Cat}_n = \sum_{i = 0}^{n - 1}\mathrm{Cat}_i\mathrm{Cat}_{n - i - 1} \end{gathered}

    简单推导:枚举第一次触碰直线 y=xy = x 的位置 (i,i)(i, i),其中 i≥1i \geq 1。

    由于在 (i,i)(i, i) 之前不能触碰直线 y=xy = x,相当于是 (1,0)→(i,i−1)(1, 0) \to (i, i - 1) 不越过直线 y=x−1y = x - 1,于是这部分的方案数为 Cati−1Catn−i\mathrm{Cat}_{i - 1}\mathrm{Cat}_{n - i}。

    卡特兰数递推公式 2:

    Cat0=1Catn=4n−2n+1Catn−1\begin{gathered} \mathrm{Cat}_0 = 1\\ \mathrm{Cat}_n = \frac{4n - 2}{n + 1}\mathrm{Cat}_{n - 1} \end{gathered}

    常见卡特兰数问题:

    • 从原点 (0,0)(0, 0) 出发,每次只能向 xx 轴或 yy 轴正方向走,且不能越过直线 y=xy = x,到达 (n,n)(n, n) 的方案数 Catn\mathrm{Cat}_n。
    • 以 1,2,…,n1, 2, \dots, n 作为 nn 个元素的进栈序列时,出栈序列的方案数 Catn\mathrm{Cat}_n。
    • 以 nn 对括号组成的合法括号序列的方案数 Catn\mathrm{Cat}_n。
    • 以 nn 个节点构造无标号、左右儿子区分的二叉树个数 Catn\mathrm{Cat}_n。
    • 以 nn 个节点构造无标号、儿子区分的有根树个数 Catn−1\mathrm{Cat}_{n - 1}。
    • 以圆周上的 2n2n 个点为端点,连互不相交的 nn 条弦的方案数 Catn\mathrm{Cat}_n。
    • 将凸 nn 边形用其中 n−3n - 3 条对角线分割为互不重叠的 n−2n - 2 个三角形的方案数 Catn−2\mathrm{Cat}_{n - 2}。
    • 将 1∼2n1 \sim 2n 中的每个数,不重不漏地填入一个 2×n2 \times n 的矩阵,每个元素大于其左方、上方元素的方案数 Catn\mathrm{Cat}_n。

    贝尔数

    贝尔数:BnB_n,表示将 nn 个两两不同的元素,划分成若干个互不区分的非空子集的方案数。

    下标从 00 开始的若干项:

    1,1,2,5,15,52,203,877,4140,21147,115975,678570,4213597,27644437,190899322,1382958545,…\begin{gathered} \textcolor{gray}{1}, 1, 2, 5, 15, \\ 52, 203, 877, 4140, \\ 21147, 115975, 678570, 4213597, \\ 27644437, 190899322, 1382958545, \dots \end{gathered}

    贝尔数递推公式:

    B0=1Bn=∑i=0n−1(n−1i)Bi\begin{gathered} B_0 = 1 \\ B_n = \sum_{i = 0}^{n - 1} \binom{n - 1}{i}B_i \end{gathered}

    简单推导:枚举与元素 nn 在同一集合的元素个数 ii,共有 (n−1i)\binom{n - 1}{i} 种选法,剩下的元素继续划分,于是这部分的方案数为 (n−1i)Bn−1−i\binom{n - 1}{i}B_{n - 1 - i}。

    贝尔数级别的暴搜:当我们需要将 nn 个两两不同的元素,划分成若干个互不区分的非空子集时,若 nn 较小可以直接暴搜,复杂度为 BnB_n 级别。

    设 s1,…,sts_1, \dots, s_{t} 表示当前时刻已经存在的集合,每次加入一个新元素 xx 时有两种转移

    • 选择一个已经存在的集合 sis_i,将 xx 加入 sis_i。
    • 新开一个集合 st+1s_{t + 1},将 xx 加入 st+1s_{t + 1}。

    贝尔数与第二类斯特林数的关系:

    Bn=∑i=0n{ni}B_n = \sum_{i = 0}^n {n \brace i}

    因为第二类斯特林数 {ni}{n \brace i} 表示将 nn 个两两不同的元素,划分成 ii 个互不区分的非空子集的方案数。

    斐波那契数列

    斐波那契数列:Fibn\mathrm{Fib}_n。

    斐波那契数列递推公式:

    Fib0=0,Fib1=1Fibn=Fibn−1+Fibn−2\begin{gathered} \mathrm{Fib}_0 = 0, \mathrm{Fib}_1 = 1\\ \mathrm{Fib}_n = \mathrm{Fib}_{n - 1} + \mathrm{Fib}_{n - 2} \end{gathered}

    斐波那契数列递推公式(矩阵形式):

    [FibnFibn−1]=[Fibn−1Fibn−2]×[1110]\begin{bmatrix} \mathrm{Fib}_n & \mathrm{Fib}_{n - 1} \end{bmatrix} = \begin{bmatrix} \mathrm{Fib}_{n - 1} & \mathrm{Fib}_{n - 2} \end{bmatrix} \times \begin{bmatrix} 1 & 1 \\ 1 & 0 \end{bmatrix}

    即

    [FibnFibn−1]=[10]×[1110]n−1\begin{bmatrix} \mathrm{Fib}_n & \mathrm{Fib}_{n - 1} \end{bmatrix} = \begin{bmatrix} 1 & 0 \end{bmatrix} \times \begin{bmatrix} 1 & 1 \\ 1 & 0 \end{bmatrix}^{n - 1}

    该转移矩阵可以求逆,从而实现逆向转移。

    斐波那契数列通项公式:

    Fibn=(1+52)n−(1−52)n5\mathrm{Fib}_n = \frac{\left( \frac{1 + \sqrt{5}}{2} \right)^n - \left( \frac{1 - \sqrt{5}}{2} \right)^n}{\sqrt{5}}

    当 55 是模 pp 意义下的二次剩余时(一个常见模数是 109+910^9 + 9),可以直接暴力预先找出 5\sqrt{5},然后使用通项公式计算。

    否则,考虑使用扩展数域进行计算,定义扩展数域 Fp(5)\mathbb{F}_p(\sqrt{5}) 为

    {a+b5∣a,b∈Fp}\{ a + b\sqrt{5} \mid a, b \in \mathbb{F}_p \}

    可以验证,Fp(5)\mathbb{F}_p(\sqrt{5}) 关于加、减、乘、除封闭。记 (a,b)(a, b) 表示 a+b5a + b\sqrt{5},则有

    (a,b)±(c,d)=(a±c,b±d)(a,b)×(c,d)=(ac+5bd,ad+bc)(a,b)÷(c,d)=(ac−5bdc2−5d2,bc−adc2−5d2)\begin{aligned} (a, b) \pm (c, d) & = (a\pm c, b\pm d) \\ (a, b) \times (c, d) & = (ac + 5bd, ad + bc) \\ (a, b) \div (c, d) & = \left( \frac{ac - 5bd}{c^2 - 5d^2} , \frac{bc - ad}{c^2 - 5d^2} \right) \end{aligned}

    广义斐波那契数列:将递推公式反过来写,有 Fibn=Fibn+2−Fibn+1\mathrm{Fib}_n = \mathrm{Fib}_{n + 2} - \mathrm{Fib}_{n + 1}。

    考虑将斐波那契数列扩展到负数域,经过推导可得

    Fib−n=(−1)n−1Fibn\mathrm{Fib}_{-n} = (-1)^{n - 1}\mathrm{Fib}_n

    类斐波那契数列:已知数列 G0=a,G1=bG_0 = a, G_1 = b,Gn=Gn−1+Gn−2G_n = G_{n - 1} + G_{n - 2},则有

    Gn=Fibn−1×a+Fibn×bG_n = \mathrm{Fib}_{n - 1} \times a + \mathrm{Fib}_n \times b

    类斐波那契数列相加,仍然是类斐波那契数列。只需将相应的 a,ba, b 相加即可。

    斐波那契数列常见恒等式

    斐波那契数列求和:

    ∑i=1nFibi=Fibn+2−1\sum_{i = 1}^n \mathrm{Fib}_i = \mathrm{Fib}_{n + 2} - 1

    斐波那契数列平方和:

    ∑i=1nFibi2=FibnFibn+1\sum_{i = 1}^n \mathrm{Fib}_i^2 = \mathrm{Fib}_n\mathrm{Fib}_{n + 1}

    卡西尼性质:

    Fibn−1Fibn+1−Fibn2=(−1)n\mathrm{Fib}_{n - 1}\mathrm{Fib}_{n + 1} - \mathrm{Fib}_n^2 = (-1)^n

    简单推导:Fibn−1Fibn+1−Fibn2=det⁡(Fibn+1FibnFibnFibn−1)=det⁡(1110)n=(−1)n\mathrm{Fib}_{n - 1}\mathrm{Fib}_{n + 1} - \mathrm{Fib}_n^2 = \det\begin{pmatrix} \mathrm{Fib}_{n + 1} & \mathrm{Fib}_n \\\mathrm{Fib}_n & \mathrm{Fib}_{n - 1} \end{pmatrix} = \det\begin{pmatrix} 1 & 1 \\1 & 0 \end{pmatrix}^n = (-1)^n。

    附加性质:

    Fibn+m=Fibn+1Fibm+FibnFibm−1\mathrm{Fib}_{n + m} = \mathrm{Fib}_{n + 1}\mathrm{Fib}_m + \mathrm{Fib}_n\mathrm{Fib}_{m - 1}

    简单推导:可以使用“类斐波那契数列”的知识解释。

    记 G0=Fibn,G1=Fibn+1G_0 = \mathrm{Fib}_n, G_1 = \mathrm{Fib}_{n + 1},Gk=Gk−1+Gk−2G_k = G_{k - 1} + G_{k - 2},则有 Fibn+m=Gm\mathrm{Fib}_{n + m} = G_m。

    斐波那契数列相邻项互质性质:

    gcd⁡(Fibn,Fibn+1)=1\gcd(\mathrm{Fib}_n, \mathrm{Fib}_{n + 1}) = 1

    斐波那契数列 gcd 性质:

    gcd⁡(Fibn,Fibm)=Fibgcd⁡(n,m)\gcd(\mathrm{Fib}_n, \mathrm{Fib}_m) = \mathrm{Fib}_{\gcd(n, m)}

    简单推导:不妨设 n<mn < m,则有

    gcd⁡(Fibn,Fibm)=gcd⁡(Fibn,Fibn+(m−n))=gcd⁡(Fibn,Fibn+1Fibm−n+FibnFibm−n−1)=gcd⁡(Fibn,Fibn+1Fibm−n)\begin{aligned} \gcd(\mathrm{Fib}_n, \mathrm{Fib}_m) & = \gcd(\mathrm{Fib}_n, \mathrm{Fib}_{n + (m - n)}) \\ & = \gcd(\mathrm{Fib}_n, \mathrm{Fib}_{n + 1}\mathrm{Fib}_{m - n} + \mathrm{Fib}_n\mathrm{Fib}_{m - n - 1}) \\ & = \gcd(\mathrm{Fib}_n, \mathrm{Fib}_{n + 1}\mathrm{Fib}_{m - n}) \end{aligned}

    由上文提到的 Fibn+1\mathrm{Fib}_{n + 1} 与 Fibn\mathrm{Fib}_n 互质,则有 gcd⁡(Fibn,Fibm)=gcd⁡(Fibn,Fibm−n)\gcd(\mathrm{Fib}_n, \mathrm{Fib}_m) = \gcd(\mathrm{Fib}_n, \mathrm{Fib}_{m - n})。该式子与辗转相除法相似,得证。

    斐波那契数列整除性质:

    Fibn∣Fibm  ⟺  n≤2∨n∣m\mathrm{Fib}_n \mid \mathrm{Fib}_m \iff n \leq 2 \lor n \mid m

    斐波那契数列模意义下的循环节

    在模意义下,二元组 (Fibn mod p,Fibn+1 mod p)(\mathrm{Fib}_n \bmod p, \mathrm{Fib}_{n + 1} \bmod p) 仅有 p2p^2 种取值。因此,当 nn 足够大时,必定会出现循环节。

    根据递推式,有 Fibn=Fibn+2−Fibn+1\mathrm{Fib}_n = \mathrm{Fib}_{n + 2} - \mathrm{Fib}_{n + 1},也就是说 Fibn+1,Fibn+2\mathrm{Fib}_{n + 1}, \mathrm{Fib}_{n + 2} 的前面必为 Fibn\mathrm{Fib}_n。

    根据这两个事实我们可以得知,斐波那契数列在模意义下必有循环节,并且一定是纯循环的(循环节的起点为 Fib0,Fib1\mathrm{Fib}_0, \mathrm{Fib}_1)。

    最小循环节(皮萨诺周期):定义斐波那契数列模 pp 意义下的最小循环节 π(p)\pi(p) 为最小的正整数 mm,使得 Fibm≡0(modp)\mathrm{Fib}_m \equiv 0 \pmod p 且 Fibm+1≡1(modp)\mathrm{Fib}_{m + 1} \equiv 1 \pmod p。

    注意:周期一定是最小循环节的倍数,即

    {Fibk≡0(modp)Fibk+1≡1(modp)  ⟺  π(p)∣k\begin{cases} \mathrm{Fib}_k \equiv 0 \pmod p \\ \mathrm{Fib}_{k + 1} \equiv 1 \pmod p \end{cases} \iff \pi(p) \mid k

    很多时候我们只需求出周期即可。

    最小循环节的上界:斐波那契数列 mod⁡m\operatorname{mod} m 的最小正周期不超过 6m6m,即 π(m)≤6m\pi(m) \leq 6m。

    求斐波那契数列循环节(结论法):

    • 质数情景:
      • π(2)=3\pi(2) = 3,π(5)=20\pi(5) = 20。
      • 当 pp 为奇质数且 p≡±1(mod5)p \equiv \pm 1 \pmod 5 时,π(p)∣p−1\pi(p) \mid p - 1。
      • 当 pp 为奇质数且 p≡±2(mod5)p \equiv \pm 2 \pmod 5 时,π(p)∣2p+2\pi(p) \mid 2p + 2。
    • 一般情景:
      • 对于质数 pp 以及任意正整数 kk,有 π(pk)∣pk−1π(p)\pi(p^k) \mid p^{k - 1}\pi(p)。
      • 对于 m=∏picim = \prod p_i^{c_i},有 π(m)=lcm{π(pici)}\pi(m) = \mathrm{lcm}\{ \pi(p_i^{c_i}) \},同时有 π(m)∣lcm{pici−1π(pi)}\pi(m) \mid \mathrm{lcm}\{ p_i^{c_i - 1}\pi(p_i) \}。

    在一般应用中,通常只需要求出一个循环节即可。

    对于质数 pp,记

    g(p)={3p=220p=5p−1p≡±1(mod5)2p+2p≡±2(mod5)g(p) = \begin{cases} 3 & p = 2 \\ 20 & p = 5 \\ p - 1 & p \equiv \pm 1 \pmod 5\\ 2p + 2 & p \equiv \pm 2 \pmod 5 \end{cases}

    然后将 mm 质因数分解成 ∏pici\prod p_i^{c_i},使用 lcm{pici−1g(pi)}\mathrm{lcm}\{ p_i^{c_i - 1}g(p_i) \} 作为循环节即可(注意这并不是最小循环节,这个值在多数情况下已经够用了)。

    求斐波那契数列循环节(矩阵 BSGS):

    适用场景:最小循环节的上界确定,转移矩阵可逆。

    考虑斐波那契数列的矩阵表示

    [FibnFibn−1]=[10]×[1110]n−1\begin{bmatrix} \mathrm{Fib}_n & \mathrm{Fib}_{n - 1} \end{bmatrix} = \begin{bmatrix} 1 & 0 \end{bmatrix} \times \begin{bmatrix} 1 & 1 \\ 1 & 0 \end{bmatrix}^{n - 1}

    记转移矩阵 A=[1110]A = \begin{bmatrix} 1 & 1 \\ 1 & 0 \end{bmatrix},那么循环节即为满足 Am≡I(modp)A^m \equiv I \pmod p 的正整数 mm。

    在转移矩阵可逆的情况下,套用 BSGS 的流程:取 SS 表示上界的根号,设 m=iS−jm = iS - j(其中 i≥1i \geq 1 且 0≤j<S0 \leq j < S),则有

    AiS×A−j≡I(modp)AiS≡Aj(modp)\begin{gathered} A^{iS} \times A^{-j} \equiv I \pmod p \\ A^{iS} \equiv A^j \pmod p \end{gathered}

    预处理 0≤j<S0 \leq j < S 的 AjA^j 存入哈希表,每次在哈希表中查询 AiSA^{iS} 即可。

    时间复杂度 O(p)\mathcal{O}(\sqrt{p})。

    求斐波那契数列循环节(生日悖论随机化):

    若存在两个数 0≤i,j≤6p0 \leq i, j \leq 6p (i≠ji \neq j),满足 (Fibi,Fibi+1)≡(Fibj,Fibj+1)(modp)(\mathrm{Fib}_i, \mathrm{Fib}_{i + 1}) \equiv (\mathrm{Fib}_j, \mathrm{Fib}_{j + 1}) \pmod p,则 ∣i−j∣|i - j| 为一个循环节(注意这并不是最小循环节)。

    每次新随机一个数 xx,将二元组 (Fibx,Fibx+1)(\mathrm{Fib}_x, \mathrm{Fib}_{x + 1}) 存入哈希表中,并查询哈希表中有没有与之相同的 (Fiby,Fiby+1)(\mathrm{Fib}_y, \mathrm{Fib}_{y + 1})。

    发现这与生日悖论的形式很像,于是时间复杂度正确。

    生日悖论:在 [1,n][1, n] 中随机选择正整数,选出两个相同数的期望轮数为 O(n)\mathcal{O}(\sqrt{n}) 级别(近似 πn2\sqrt{\frac{\pi n}{2}})。

    实际取数过程可能需要在 [0,12p][0, 12p] 中随机以保证期望次数。求 Fibi\mathrm{Fib}_{i} 需要用到“光速幂”的技巧。

    普通生成函数

    普通生成函数(OGF):

    F(x)=∑nanxnF(x) = \sum_{n} a_nx^n

    OGF 乘法:

    F(x)G(x)=∑n(∑i=0naibn−i)xnF(x)G(x) = \sum_{n} \left( \sum_{i = 0}^n a_ib_{n - i} \right)x^n

    OGF 常用于解决无标号的计数问题(例如:优化计数类背包)。

    常见序列 OGF 封闭形式:

    • {1,1,1,… }→OGF11−x\{1, 1, 1, \dots \} \xrightarrow{\mathrm{OGF}} \frac{1}{1 - x}
    • {1,p,p2,… }→OGF11−px\{1, p, p^2, \dots \} \xrightarrow{\mathrm{OGF}} \frac{1}{1 - px}
    • {(n0),(n1),(n2),… }→OGF(1+x)n\{ \binom{n}{0}, \binom{n}{1}, \binom{n}{2}, \dots \} \xrightarrow{\mathrm{OGF}} (1 + x)^n
    • {(n0),(n+11),(n+22),… }→OGF1(1−x)n+1\{ \binom{n}{0}, \binom{n + 1}{1}, \binom{n + 2}{2}, \dots \} \xrightarrow{\mathrm{OGF}} \frac{1}{(1 - x)^{n + 1}}
    • {0,1,12,13,14,… }→OGFln⁡11−x=−ln⁡(1−x)\{ 0, 1, \frac{1}{2}, \frac{1}{3}, \frac{1}{4}, \dots \} \xrightarrow{\mathrm{OGF}} \ln \frac{1}{1 - x} = -\ln(1 - x)
    • {1,1,12!,13!,14!,… }→OGFex\{ 1, 1, \frac{1}{2!}, \frac{1}{3!}, \frac{1}{4!}, \dots \} \xrightarrow{\mathrm{OGF}} e^x

    指数生成函数

    指数生成函数(EGF):

    F(x)=∑nanxnn!F(x) = \sum_{n} a_n \frac{x^n}{n!}

    EGF 乘法:

    F(x)G(x)=∑n(∑i=0n(ni)aibn−i)xnn!F(x)G(x) = \sum_{n} \left( \sum_{i = 0}^n \binom{n}{i}a_ib_{n - i} \right)\frac{x^n}{n!}

    EGF 常用于解决有标号的计数问题。

    常见序列 EGF 封闭形式:

    • {1,1,1,… }→EGFex\{1, 1, 1, \dots\} \xrightarrow{\mathrm{EGF}} e^x
    • {1,p,p2,… }→EGFepx\{1, p, p^2, \dots\} \xrightarrow{\mathrm{EGF}} e^{px}
    • {1,n,n2‾,n3‾,n4‾,… }→EGF(1+x)n\{1, n, n^{\underline{2}}, n^{\underline{3}}, n^{\underline{4}}, \dots \} \xrightarrow{\mathrm{EGF}} (1 + x)^n

    EGF 中多项式 exp 的组合意义:

    回顾一下 exp 的式子(在这里我们默认 [x0]f(x)=0[x^0]f(x) = 0)

    exp⁡f(x)=∑i=0∞fi(x)i!\exp f(x) = \sum\limits_{i = 0}^{\infty} \frac{f^i(x)}{i!}

    如果 f(x)f(x) 描述的是单个组件的 EGF,那么 fk(x)f^k(x) 得到的就是由 kk 个组件构成的有序序列的 EGF,但是如果我们将这 kk 个组件看成一个集合,就要除以 k!k! 来消除顺序的影响。

    所以 fk(x)k!\frac{f^k(x)}{k!} 的含义是由 kk 个组件构成的无序集合的 EGF。因此,exp⁡f(x)\exp f(x) 的含义是由若干个组件构成的无序集合的 EGF。

    符号化方法

    待填坑。

    图论计数

    有标号无向连通图计数

    算法一:分治 NTT

    设 fif_i 表示点数为 ii 的有标号简单无向连通图个数,设 gig_i 表示点数为 ii 的有标号简单无向图个数,显然 gi=2(i2)g_i = 2^{\binom{i}{2}}。

    考虑容斥。枚举点 11 所在的连通块大小,有递推式

    f1=1fi=gi−∑j=1i−1(i−1j−1)fjgi−j\begin{gathered} f_1 = 1 \\ f_i = g_i - \sum_{j = 1}^{i - 1}\binom{i - 1}{j - 1}f_jg_{i - j} \end{gathered}

    化简式子,得

    fi(i−1)!=gi(i−1)!−∑j=1i−1fj(j−1)!gi−j(i−j)!\frac{f_i}{(i - 1)!} = \frac{g_i}{(i - 1)!} - \sum_{j = 1}^{i - 1}\frac{f_j}{(j - 1)!} \frac{g_{i - j}}{(i - j)!}

    使用分治 NTT,时间复杂度 O(nlog⁡2n)\mathcal{O}(n \log^2 n)。

    另一种理解方式:设 Fi=fi(i−1)!,Gi=gi(i−1)!,Hi=gii!F_i = \frac{f_i}{(i - 1)!}, G_i = \frac{g_i}{(i - 1)!}, H_i = \frac{g_i}{i!},可以将该递推式看成 G=F×HG = F \times H,于是 F=G×H−1F = G \times H^{-1}。

    使用多项式求逆,时间复杂度 O(nlog⁡n)\mathcal{O}(n \log n)。

    算法二:多项式 ln

    设 F(x)F(x) 是 fif_i 的 EGF,G(x)G(x) 是 gig_i 的 EGF。由 EGF 中多项式 exp 的组合意义,有 G(x)=eF(x)G(x) = e^{F(x)}。所以

    F(x)=ln⁡G(x)F(x) = \ln G(x)

    使用多项式 ln,时间复杂度 O(nlog⁡n)\mathcal{O}(n \log n)。

    0x33 有标号无向连通图计数.cpp:

    // 有标号无向连通图计数
    poly GraphCount(int n) {
        std::vector<int> fact(n + 1), facv(n + 1);
        fact[0] = 1;
        for (int i = 1; i <= n; i ++) {
            fact[i] = 1ll * fact[i - 1] * i % mod;
        }
        facv[n] = qpow(fact[n], mod - 2, mod);
        for (int i = n - 1; i >= 0; i --) {
            facv[i] = 1ll * facv[i + 1] * (i + 1) % mod;
        }
    
        poly g(n + 1);
        for (int i = 0; i <= n; i ++) {
            g[i] = 1ll * qpow(2, 1ll * i * (i - 1) / 2, mod) * facv[i] % mod;
        }
        poly f = g.ln(n + 1);
        for (int i = 0; i <= n; i ++) {
            mul(f[i], fact[i]);
        }
        return f;
    }

    有标号无向欧拉图计数

    欧拉图的条件:所有节点的度数均为偶数,并且连通。

    设 fif_i 表示点数为 ii 的有标号简单无向欧拉图个数,设 gig_i 表示点数为 ii 的有标号度数均为偶数的简单图个数。

    考虑求 gig_i,先让前 i−1i - 1 个点任意连边,最后所有奇点的度数都通过与 ii 连边调节成偶数。于是 gi=2(i−12)g_i = 2^{\binom{i - 1}{2}}。

    剩余部分同“有标号无向连通图计数”,时间复杂度 O(nlog⁡n)\mathcal{O}(n \log n)。

    0x33 有标号无向欧拉图计数.cpp:

    // 有标号无向欧拉图计数
    poly GraphCount(int n) {
        std::vector<int> fact(n + 1), facv(n + 1);
        fact[0] = 1;
        for (int i = 1; i <= n; i ++) {
            fact[i] = 1ll * fact[i - 1] * i % mod;
        }
        facv[n] = qpow(fact[n], mod - 2, mod);
        for (int i = n - 1; i >= 0; i --) {
            facv[i] = 1ll * facv[i + 1] * (i + 1) % mod;
        }
    
        poly g(n + 1);
        g[0] = 1;
        for (int i = 1; i <= n; i ++) {
            g[i] = 1ll * qpow(2, 1ll * (i - 1) * (i - 2) / 2, mod) * facv[i] % mod;
        }
        poly f = g.ln(n + 1);
        for (int i = 0; i <= n; i ++) {
            mul(f[i], fact[i]);
        }
        return f;
    }

    有标号无向二分图计数

    设 fif_i 表示点数为 ii 的有标号简单无向二分图个数,设 gig_i 表示点数为 ii 的**对节点进行 22 染色,满足同色节点不存在边的图(二分染色图)**个数。

    考虑求 gig_i,枚举黑色节点个数 jj,则有

    gi=∑j=0i(ij)2j(i−j)gi=∑j=0i(ij)2(i2)−(j2)−(i−j2)gii!⋅2(i2)=∑j=0i1j!⋅2(j2)⋅1(i−j)!⋅2(i−j2)\begin{gathered} g_i = \sum_{j = 0}^i \binom{i}{j} 2^{j(i - j)} \\ g_i = \sum_{j = 0}^i \binom{i}{j} 2^{\binom{i}{2} - \binom{j}{2} - \binom{i - j}{2}} \\ \frac{g_i}{i! \cdot 2^{\binom{i}{2}}} = \sum_{j = 0}^i \frac{1}{j! \cdot 2^{\binom{j}{2}}} \cdot \frac{1}{(i - j)! \cdot 2^{\binom{i - j}{2}}} \end{gathered}

    这里用到了 ij=(i+j2)−(i2)−(j2)ij = \binom{i + j}{2} - \binom{i}{2} - \binom{j}{2}。

    可以使用卷积 O(nlog⁡n)\mathcal{O}(n \log n) 求出 gig_i。

    对于二分染色图的每一个连通块,确定了最小点的颜色就确定了整个连通块的颜色,而最小点有黑白两种选法。

    则二分染色图可以由两个组件构成,第一个组件是最小点颜色为黑色的连通块集合,第二个组件是最小点颜色为白色的连通块集合。而两个组件内部均是二分图。

    于是设 F(x)F(x) 是 fif_i 的 EGF,G(x)G(x) 是 gig_i 的 EGF,则有

    F(x)×F(x)=G(x)F(x)=G(x)\begin{gathered} F(x) \times F(x) = G(x) \\ F(x) = \sqrt{G(x)} \end{gathered}

    使用多项式开方,时间复杂度 O(nlog⁡n)\mathcal{O}(n \log n)。

    0x33 有标号无向二分图计数.cpp:

    // 有标号无向二分图计数
    poly GraphCount(int n) {
        std::vector<int> fact(n + 1), facv(n + 1);
        fact[0] = 1;
        for (int i = 1; i <= n; i ++) {
            fact[i] = 1ll * fact[i - 1] * i % mod;
        }
        facv[n] = qpow(fact[n], mod - 2, mod);
        for (int i = n - 1; i >= 0; i --) {
            facv[i] = 1ll * facv[i + 1] * (i + 1) % mod;
        }
    
        poly a(n + 1);
        for (int i = 0, i2 = qpow(2, mod - 2, mod); i <= n; i ++) {
            a[i] = 1ll * facv[i] * qpow(i2, 1ll * i * (i - 1) / 2, mod) % mod;
        }
        poly g = (a * a).modxk(n + 1);
        for (int i = 0; i <= n; i ++) {
            mul(g[i], qpow(2, 1ll * i * (i - 1) / 2, mod));
        }
        poly f = g.sqrt(n + 1);
        for (int i = 0; i <= n; i ++) {
            mul(f[i], fact[i]);
        }
        return f;
    }

    有标号 DAG 计数

    设 fif_i 表示点数为 ii 的**有标号 DAG(不保证弱连通)**个数。

    将 DAG 视作一个分层图,考虑容斥,钦定拓扑序第一层(零入度点)的个数。

    fi=∑j=1i(−1)j+1(ij)2j(i−j)fi−jf_i = \sum_{j = 1}^{i}(-1)^{j + 1} \binom{i}{j} 2^{j(i - j)}f_{i - j}

    至此,可以做到 O(n2)\mathcal{O}(n^2)。

    进一步

    fii!⋅2(i2)=∑j=1i(−1)j+1j!⋅2(j2)⋅fi−j(i−j)!⋅2(i−j2)\frac{f_i}{i! \cdot 2^\binom{i}{2}} = \sum_{j = 1}^i \frac{(-1)^{j + 1}}{j! \cdot 2^\binom{j}{2}} \cdot \frac{f_{i - j}}{(i - j)! \cdot 2^\binom{i - j}{2}}

    设 Fi=fii!⋅2(i2),Gj=(−1)j+1j!⋅2(j2)F_i = \frac{f_i}{i! \cdot 2^\binom{i}{2}}, G_j = \frac{(-1)^{j + 1}}{j! \cdot 2^\binom{j}{2}} (G0=0G_0 = 0),则有

    F=G×F+1F=11−G\begin{gathered} F = G\times F + 1 \\ F = \frac{1}{1 - G} \end{gathered}

    使用多项式求逆,时间复杂度 O(nlog⁡n)\mathcal{O}(n \log n)。

    0x33 有标号 DAG 计数.cpp:

    // 有标号 DAG 计数
    poly GraphCount(int n) {
        std::vector<int> fact(n + 1), facv(n + 1);
        fact[0] = 1;
        for (int i = 1; i <= n; i ++) {
            fact[i] = 1ll * fact[i - 1] * i % mod;
        }
        facv[n] = qpow(fact[n], mod - 2, mod);
        for (int i = n - 1; i >= 0; i --) {
            facv[i] = 1ll * facv[i + 1] * (i + 1) % mod;
        }
    
        poly g(n + 1);
        g[0] = 0;
        for (int i = 1, i2 = qpow(2, mod - 2, mod); i <= n; i ++) {
            g[i] = 1ll * facv[i] * qpow(i2, 1ll * i * (i - 1) / 2, mod) % mod;
            if ((i + 1) & 1) neg(g[i]);
        }
        poly f = (poly{1} - g).inv(n + 1);
        for (int i = 0; i <= n; i ++) {
            mul(f[i], fact[i]), mul(f[i], qpow(2, 1ll * i * (i - 1) / 2, mod));
        }
        return f;
    }

    有标号弱连通 DAG 计数

    设 fif_i 表示点数为 ii 的有标号 DAG(不保证弱连通)个数,设 hih_i 表示点数为 ii 的有标号弱连通 DAG 个数。fif_i 的求解详见“有标号 DAG 计数”。

    设 F(x)F(x) 是 fif_i 的 EGF,H(x)H(x) 是 hih_i 的 EGF。由 EGF 中多项式 exp 的组合意义,有 F(x)=eH(x)F(x) = e^{H(x)}。所以

    H(x)=ln⁡F(x)H(x) = \ln F(x)

    使用多项式 ln,时间复杂度 O(nlog⁡n)\mathcal{O}(n \log n)。

    0x33 有标号弱连通 DAG 计数.cpp:

    // 有标号弱连通 DAG 计数
    poly GraphCount(int n) {
        std::vector<int> fact(n + 1), facv(n + 1);
        fact[0] = 1;
        for (int i = 1; i <= n; i ++) {
            fact[i] = 1ll * fact[i - 1] * i % mod;
        }
        facv[n] = qpow(fact[n], mod - 2, mod);
        for (int i = n - 1; i >= 0; i --) {
            facv[i] = 1ll * facv[i + 1] * (i + 1) % mod;
        }
    
        poly g(n + 1);
        g[0] = 0;
        for (int i = 1, i2 = qpow(2, mod - 2, mod); i <= n; i ++) {
            g[i] = 1ll * facv[i] * qpow(i2, 1ll * i * (i - 1) / 2, mod) % mod;
            if ((i + 1) & 1) neg(g[i]);
        }
        poly f = (poly{1} - g).inv(n + 1);
        for (int i = 0; i <= n; i ++) {
            mul(f[i], qpow(2, 1ll * i * (i - 1) / 2, mod));
        }
        f = f.ln(n + 1);
        for (int i = 0; i <= n; i ++) {
            mul(f[i], fact[i]);
        }
        return f;
    }

    有标号强连通图计数

    设 fif_i 表示点数为 ii 的有标号强连通图个数,设 bi,jb_{i, j} 表示 ii 个点形成 jj 个独立的强连通图的个数,设 hih_i 表示点数为 ii 的任意有向图个数。显然 hi=2i(i−1)h_i = 2^{i(i - 1)}。

    则有

    hi=∑j=1i(ij)hi−j×2j(i−j)×∑k=1j(−1)k+1bj,kh_i = \sum_{j = 1}^i \binom{i}{j} h_{i - j}\times 2^{j(i - j)} \times \sum_{k = 1}^{j}(-1)^{k + 1}b_{j, k}

    对于任意点数为 ii 的有向图,将每个强连通分量缩成一个点,会得到一张 DAG。这其中必定有出度为 00 的点。

    钦定 kk 个强连通分量出度为 00,这 kk 个强连通分量里包含了 jj 个点。剩下的 i−ji - j 个点随意连接。

    设 gj=∑k=1j(−1)k+1bj,kg_j = \sum_{k = 1}^j (-1)^{k + 1}b_{j, k},则有

    gi=hi−∑j=1i−1(ij)2j(i−j)hi−jgjhii!⋅2(i2)=∑j=1igjj!⋅2(j2)⋅hi−j(i−j)!⋅2(i−j2)\begin{gathered} g_i = h_i - \sum_{j = 1}^{i - 1} \binom{i}{j} 2^{j(i - j)} h_{i - j} g_j \\ \frac{h_i}{i! \cdot 2^{\binom{i}{2}}} = \sum_{j = 1}^i \frac{g_j}{j! \cdot 2^{\binom{j}{2}}} \cdot \frac{h_{i - j}}{(i - j)! \cdot 2^{\binom{i - j}{2}}} \end{gathered}

    设 Hi=hii!⋅2(i2),Gi=gii!⋅2(i2)H_i = \frac{h_i}{i! \cdot 2^{\binom{i}{2}}}, G_i = \frac{g_i}{i! \cdot 2^{\binom{i}{2}}},则有

    H=G×H+1G=1−1H\begin{gathered} H = G \times H + 1 \\ G = 1 - \frac{1}{H} \end{gathered}

    至此,可以使用多项式求逆求出 GG。

    再根据 gg 的定义,考虑 gg 的转移,有

    gi=fi−∑j=1i−1(i−1j−1)fjgi−jfi=gi+∑j=1i−1(i−1j−1)fjgi−jfi(i−1)!=gi(i−1)!+∑j=1i−1fj(j−1)!⋅gi−j(i−j)!\begin{gathered} g_i = f_i - \sum_{j = 1}^{i - 1} \binom{i - 1}{j - 1}f_jg_{i - j} \\ f_i = g_i + \sum_{j = 1}^{i - 1} \binom{i - 1}{j - 1}f_jg_{i - j} \\ \frac{f_i}{(i - 1)!} = \frac{g_i}{(i - 1)!} + \sum_{j = 1}^{i - 1}\frac{f_j}{(j - 1)!}\cdot \frac{g_{i - j}}{(i - j)!} \end{gathered}

    设 Fi=fi(i−1)!,Ai=gi(i−1)!,Bi=gii!F_i = \frac{f_i}{(i - 1)!}, A_i = \frac{g_i}{(i - 1)!}, B_i = \frac{g_i}{i!},则有

    F=A+F×BF=A1−B\begin{gathered} F = A + F \times B \\ F = \frac{A}{1 - B} \end{gathered}

    0x33 有标号强连通图计数.cpp:

    // 有标号强连通图计数
    poly GraphCount(int n) {
        std::vector<int> fact(n + 1), facv(n + 1);
        fact[0] = 1;
        for (int i = 1; i <= n; i ++) {
            fact[i] = 1ll * fact[i - 1] * i % mod;
        }
        facv[n] = qpow(fact[n], mod - 2, mod);
        for (int i = n - 1; i >= 0; i --) {
            facv[i] = 1ll * facv[i + 1] * (i + 1) % mod;
        }
    
        poly h(n + 1);
        h[0] = 1;
        for (int i = 1; i <= n; i ++) {
            h[i] = 1ll * qpow(2, 1ll * i * (i - 1) / 2, mod) * facv[i] % mod;
        }
        poly g2 = poly{1} - h.inv(n + 1);
        for (int i = 1; i <= n; i ++) {
            mul(g2[i], qpow(2, 1ll * i * (i - 1) / 2, mod));
        }
        poly g1 = g2;
        for (int i = 1; i <= n; i ++) {
            mul(g1[i], i);
        }
        poly f = (g1 * (poly{1} - g2).inv(n + 1)).modxk(n + 1);
        for (int i = 1; i <= n; i ++) {
            mul(f[i], fact[i - 1]);
        }
        return f;
    }

    Misc

    Raney 引理

    Raney 引理:若整数序列 x1,…,xmx_1, \dots, x_m 满足 ∑i=1mxi=1\sum_{i = 1}^m x_i = 1,则它的 mm 个循环移位中恰好有 11 个满足前缀和均为正数。

    唯一合法的循环移位起点,即为最靠后的“前缀和最小点”。

    广义 Raney 引理:若整数序列 x1,…,xmx_1, \dots, x_m 满足 xi≤1x_i \leq 1 且 ∑i=1mxi=n\sum_{i = 1}^m x_i = n,则它的 mm 个循环移位中恰好有 nn 个满足前缀和均为正数。

    0x34 数学 初等数论-质数

    质数

    质数:若一个正整数 nn (n>1n > 1) 无法被除了 11 和它自身以外的任何正整数整除,则称该数为质数(或素数)。否则称该数为合数。特别地,11 既不是质数也不是合数。

    质数分布函数:π(n)\pi(n) 表示 1∼n1 \sim n 中的质数个数。当 nn 足够大时,π(n)∼nln⁡n\pi(n) \sim \frac{n}{\ln n}。

    唯一分解定理:任意一个大于 11 的正整数 nn,都可以唯一分解成有限个质数的乘积,记作

    n=p1c1p2c2…ptctn = p_1^{c_1}p_2^{c_2}\dots p_t^{c_t}

    其中 pip_i 均为质数且满足 p1<p2<⋯<ptp_1 < p_2 < \dots < p_t,cic_i 均为正整数。

    质因数的根号分治:一个正整数 nn,大于 n\sqrt{n} 的质因子最多只有 11 个。

    阶乘的质因数分解

    对于阶乘 n!=1×2×⋯×nn! = 1 \times 2 \times \dots \times n,由于每一项均为 [1,n][1, n] 中的正整数,故分解出的质因数也均为 [1,n][1, n] 中的质数。

    筛出 1∼n1 \sim n 中的所有质数,对于每个质数 pp,考虑 n!n! 中一共包含了多少个质因子 pp。

    共有大约 nln⁡n\frac{n}{\ln n} 个质数,每个质数 pp 的求解需要 log⁡pn\log_p n 的开销,故时间复杂度 O(n)\mathcal{O}(n)。

    阶乘 n!n! 中包含质数 pp 的次数:

    ∑i=1⌊log⁡pn⌋⌊npi⌋\sum_{i = 1}^{\lfloor \log_p n \rfloor} \left\lfloor \frac{n}{p^i} \right\rfloor

    简单推导:设 cic_i 表示 ii 包含的质因子 pp 个数,则阶乘 n!n! 包含 pp 的个数为 ∑j=1∞∑i=1nj[ci=j]\sum_{j = 1}^{\infty} \sum_{i = 1}^n j[c_i = j],进一步得 ∑j=1∞∑i=1n[ci≥j]\sum_{j = 1}^{\infty}\sum_{i = 1}^n [c_i \geq j],不难发现其中 ∑i=1n[ci≥j]=⌊npj⌋\sum_{i = 1}^n [c_i \geq j] = \left\lfloor \frac{n}{p^j} \right\rfloor。

    阶乘 n!n! 中包含合数 mm 的次数:将 mm 唯一分解成 m=p1c1p2c2…ptctm = p_1^{c_1}p_2^{c_2}\dots p_t^{c_t} 的形式。

    记 vp(n)=∑i=1⌊log⁡pn⌋⌊npi⌋v_p(n) = \sum_{i = 1}^{\lfloor \log_p n \rfloor} \left\lfloor \frac{n}{p^i} \right\rfloor,答案为

    min⁡1≤i≤t⌊vpi(n)ci⌋\min_{1 \leq i \leq t} \left\lfloor \frac{v_{p_i}(n)}{c_i} \right\rfloor

    埃氏筛

    注意到,任意整数 xx (x>1x > 1) 的倍数 2x,3x,…2x, 3x, \dots 都不是质数。

    从 22 到 nn 依次扫描每一个数 xx,若 xx 尚未被标记,则说明 xx 为质数,并且将其倍数 2x,3x,…,⌊nx⌋x2x, 3x, \dots, \left\lfloor \frac{n}{x} \right\rfloor x 均标记为合数。

    时间复杂度 O(nlog⁡log⁡n)\mathcal{O}(n \log \log n)。

    在开 O2 优化的情况下,std::bitset 连续读写效率较高,可以用来优化埃氏筛。

    埃氏筛的时间复杂度证明:相当于是证明 1∼n1 \sim n 中所有质数的倒数之和为 O(log⁡log⁡n)\mathcal{O}(\log \log n) 级别。

    由质数分布函数,可以推测第 nn 个质数的大小为 Θ(nlog⁡n)\Theta(n \log n),于是有

    ∑k=1π(n)1pk=O(∑k=2π(n)1klog⁡k)=O(∫2π(n)1xlog⁡xdx)=O(log⁡log⁡π(n))=O(log⁡log⁡n)\begin{aligned} \sum_{k = 1}^{\pi(n)} \frac{1}{p_k} & = \mathcal{O}\left( \sum_{k = 2}^{\pi(n)} \frac{1}{k \log k} \right) \\ & = \mathcal{O}\left(\int_2^{\pi(n)} \frac{1}{x \log x} \mathrm{dx} \right) \\ & = \mathcal{O}(\log \log \pi(n)) \\ & = \mathcal{O}(\log \log n) \end{aligned}

    0x34 埃氏筛.cpp:

    // 埃氏筛
    std::bitset<MaxV> vis;
    void sieve(int n) {
        for (int i = 2; i <= n; i ++) {
            if (vis[i]) {
                continue;
            }
            for (int j = 2; j <= n / i; j ++) {
                vis[i * j] = 1;
            }
        }
    }

    线性筛

    为了避免埃氏筛重复标记合数,在线性筛中,我们希望确定一个合数的方式能够唯一。

    从 22 到 nn 依次扫描每一个数 xx,在标记合数时,我们只在 xx 的基础上乘一个质因子 pp,并且保证 pp 是 xpxp 的最小质因子。这样做,每个合数只会被自己的最小质因子标记一次。并且顺带还能筛出每个数的最小质因子。

    时间复杂度 O(n)\mathcal{O}(n)。

    由于线性筛每次只扩展一个最小质因子的结构,可以额外处理很多信息(例如筛出积性函数)。

    0x34 线性筛.cpp:

    // 线性筛
    int primeCount, prime[MaxV], fac[MaxV];
    void sieve(int n) {
        for (int i = 2; i <= n; i ++) {
            if (!fac[i]) {
                prime[++ primeCount] = i, fac[i] = i;
            }
            for (int j = 1; j <= primeCount; j ++) {
                if (prime[j] > fac[i] || prime[j] > n / i) break;
                fac[i * prime[j]] = prime[j];
            }
        }
    }

    狄利克雷前缀和

    狄利克雷前缀和:已知 a1,…,ana_1, \dots, a_n,求出 b1,…,bnb_1, \dots, b_n,其中 bi=∑j∣iajb_i = \sum_{j \mid i} a_j。

    记 j=∏pkαk,i=∏pkβkj = \prod p_k^{\alpha_k}, i = \prod p_k^{\beta_k},则 aja_j 对 bib_i 有贡献当且仅当:对于所有的 kk 均有 αk≤βk\alpha_k \leq \beta_k。类似地,运用高维前缀和即可。

    // 注意:要先枚举质数 prime[j]
    for (int j = 1; j <= primeCount; j ++) {
        for (int i = 1; i <= n / prime[j]; i ++) {
            f[i * prime[j]] += f[i];
        }
    }

    狄利克雷后缀和:已知 a1,…,ana_1, \dots, a_n,求出 b1,…,bnb_1, \dots, b_n,其中 bi=∑i∣jajb_i = \sum_{i \mid j} a_j。

    // 注意:要先枚举质数 prime[j]
    for (int j = 1; j <= primeCount; j ++) {
        for (int i = n / prime[j]; i >= 1; i --) {
            f[i] += f[i * prime[j]];
        }
    }

    狄利克雷倒前缀和:已知 b1,…,bnb_1, \dots, b_n,反推 a1,…,ana_1, \dots, a_n,其中 bi=∑j∣iajb_i = \sum_{j \mid i} a_j。

    // 注意:要先枚举质数 prime[j]
    for (int j = 1; j <= primeCount; j ++) {
        for (int i = n / prime[j]; i >= 1; i --) { // 顺序与正变换相反
            f[i * prime[j]] -= f[i];
        }
    }

    狄利克雷倒后缀和:已知 b1,…,bnb_1, \dots, b_n,反推 a1,…,ana_1, \dots, a_n,其中 bi=∑i∣jajb_i = \sum_{i \mid j} a_j。

    // 注意:要先枚举质数 prime[j]
    for (int j = 1; j <= primeCount; j ++) {
        for (int i = 1; i <= n / prime[j]; i ++) { // 顺序与正变换相反
            f[i] -= f[i * prime[j]];
        }
    }

    Miller-Rabin 素性测试

    回顾一些内容:

    费马小定理:设 pp 是素数,对于任意整数 aa(aa 不能是 pp 的倍数),满足 ap−1≡1(modp)a^{p - 1} \equiv 1 \pmod p。

    Fermat 伪素数:若满足 an−1≡1(modn)a^{n - 1} \equiv 1 \pmod n,但 nn 不是素数,则称 nn 为以 aa 为底的 Fermat 伪素数。

    对于任何固定的基底 aa,都存在无穷多个的 Fermat 伪素数。

    Fermat 素性测试:不断地选取在 [2,n−1][2, n - 1] 中的基底 aa,并检验是否每次都满足 an−1≡1(modn)a^{n - 1} \equiv 1\pmod n。

    即使检查了所有与 nn 互质的基底 aa,依然无法保证 nn 是素数。这样的数 nn 称为 Carmichael 数,有无穷多个。

    二次探测定理:设 pp 是奇素数,则同余方程 x2≡1(modp)x^2 \equiv 1 \pmod p 的解为 x≡1(modp)x \equiv 1 \pmod p 或 x≡p−1(modp)x \equiv p - 1\pmod p。


    Miller-Rabin 素性测试:Miller-Rabin 素性测试,结合了费马小定理和二次探测定理,是一种概率性素性测试(可以放心使用)。

    先将 an−1≡1(modn)a^{n - 1} \equiv 1 \pmod n 中的指数 n−1n - 1,分解成 n−1=u×2tn - 1 = u \times 2^t 的形式。

    每次随机一个基底 aa,进行如下的判断:

    • 先使用快速幂求出 v=au mod nv = a^u \bmod n。如果 v=1v = 1 或 v=n−1v = n - 1,则该轮测试通过。
    • 然后对这个值进行 t−1t - 1 次平方操作,途中如果该值等于 n−1n - 1,则该轮测试通过。
    • 否则该轮测试不通过。

    在不考虑乘法的开销时,对 nn 进行 kk 轮测试的时间复杂度为 O(klog⁡n)\mathcal{O}(k \log n)。

    可以证明,奇合数 nn (n>9n > 9) 通过随机选取的一个基底的概率不超过 14\frac{1}{4}。因此随机选取 kk 个基底后,仍然误判的概率不超过 14k\frac{1}{4^k}。随机选取 1010 次较为保险。

    对于 [2,264)[2, 2^{64}) 范围内的数,工业上通常选用 {2,325,9375,28178,450775,9780504,1795265022}\{ 2, 325, 9375, 28178, 450775, 9780504, 1795265022 \} 作为检验的基底。为了方便也可以选择前 1212 个质数作为基底。

    Pollard-Rho 质因数分解

    Pollard-Rho:用于找出合数 nn 的某一个非平凡因数 dd(非平凡因数:非 11 且非 nn 的因数)。

    若一个正整数 nn 为合数,那么 nn 的最小质因子 pp 满足 p≤np \leq \sqrt{n}。

    如果随机生成 O(p)\mathcal{O}(\sqrt{p}) 个正整数,由生日悖论,可能存在两个正整数 a,ba, b 满足 a≡b(modp)a \equiv b \pmod p,此时 ∣a−b∣|a - b| 是 pp 的倍数,于是查询 gcd⁡(∣a−b∣,n)\gcd(|a - b|, n) 即可得到 nn 的一个因子。

    生日悖论:在 [1,n][1, n] 中随机选择正整数,选出两个相同数的期望轮数为 O(n)\mathcal{O}(\sqrt{n}) 级别(近似 πn2\sqrt{\frac{\pi n}{2}})。

    但这样做,枚举数对的时间复杂度还是太高。

    记映射 f(x)=(x2+c) mod nf(x) = (x^2 + c) \bmod n,其中 cc 是一个随机选取的常数(c≠0,−2c \neq 0, -2)。Pollard 构造了这样的一个伪随机序列 {xi}\{x_i\},满足 xi=f(xi−1)x_i = f(x_{i - 1})。

    考虑序列 {xi mod p}\{ x_i \bmod p \},由于 xix_i 仅仅与 xi−1x_{i - 1} 有关,且 xi mod p∈[0,p)x_i \bmod p \in [0, p),所以 {xi mod p}\{ x_i \bmod p \} 是一个混循环序列。

    建图后形似 ρ\rho 形(rho),由生日悖论可得尾长与环长均为 O(p)\mathcal{O}(\sqrt{p}) 级别。

    我们发现,若 x≡y(modp)x \equiv y \pmod p,必有 f(x)≡f(y)(modp)f(x) \equiv f(y) \pmod p。由此可得在模 pp 的环上,只要某个相距 dd 步的点对满足条件,则所有相距 dd 步的点对均满足条件。所以我们每次最好要检查不同的距离。

    Brent 倍增迭代:初始有两个点 a,ba, b,在第 kk 轮,aa 原地不动,bb 不断地向前共计 2k2^k 步,最后再让 aa 直接跳到 bb 的位置。bb 的每一步移动,我们都计算 d=gcd⁡(∣a−b∣,n)d = \gcd(|a - b|, n),当第一次出现 d>1d > 1 时

    • 若 1<d<n1 < d < n,则我们已经找到了一个非平凡因数,直接返回 dd。
    • 若 d=nd = n,则说明我们已经完整地跑完了一个环,继续在环上跑也没有意义。
      此时我们应该换个映射,或者换一个初始值继续做。

    进一步,我们想要降低求解 gcd⁡\gcd 的次数。注意到,如果 gcd⁡(a,n)>1\gcd(a, n) > 1,则对于任意正整数 bb 均有 gcd⁡(ab mod n,n)=gcd⁡(ab,n)>1\gcd(ab \bmod n, n) = \gcd(ab, n) > 1。

    也就是说,如果 gcd⁡(∏∣xi−xj∣ mod n,n)>1\gcd\left(\prod |x_i - x_j| \bmod n, n\right) > 1,那么其中必有一对 xi,xjx_i, x_j 满足 gcd⁡(∣xi−xj∣,n)>1\gcd(|x_i - x_j|, n) > 1。

    于是我们每 kk 对 a,ba, b 就计算一次 gcd⁡\gcd。时间复杂度 O(p+k−1plog⁡n)\mathcal{O}(\sqrt{p} + k^{-1}\sqrt{p} \log n),当 kk 与 log⁡n\log n 大致相等时,可以得到 O(p)\mathcal{O}(\sqrt{p}) 的理论复杂度。具体实现中,一般取 k=128k = 128。

    Pollard-Rho 质因数分解:如果要对 nn 进行质因数分解,先使用 Miller-Rabin 判断 nn 是否是质数,若 nn 为合数,则使用 Pollard-Rho 找出 nn 的一个非平凡因数 dd,得到两个规模分别为 dd 和 nd\frac{n}{d} 的子问题,递归进行求解。

    0x34 素性测试与质因数分解(Miller-Rabin + Pollard-Rho).cpp:

    // 素性测试与质因数分解
    template <class T, auto qmul>
    struct primeTools {
        constexpr T qpow(T a, T b, T p) {
            T ans = 1;
            for (; b; b >>= 1) {
                if (b & 1) ans = qmul(ans, a, p);
                a = qmul(a, a, p);
            }
            return ans;
        }
    
        std::mt19937_64 mtrand{std::random_device{}()};
        T rand(T l, T r) {
            std::uniform_int_distribution<T> range(l, r);
            return range(mtrand);
        }
    
        // 素性测试 Miller-Rabin
        bool isPrime(T n) {
            assert(n > 1);
            if (n % 2 == 0) return n == 2;
            if (n % 3 == 0) return n == 3;
    
            T t = __builtin_ctzll(n - 1);
            T u = (n - 1) >> t;
    
            int test = 6;
            while (test --) {
                T a = rand(2, n - 1);
                T v = qpow(a, u, n);
                if (v == 1 || v == n - 1) {
                    continue;
                }
                for (int i = 1; i < t; i ++) {
                    v = qmul(v, v, n);
                    if (v == n - 1) {
                        break;
                    }
                }
                if (v != n - 1) {
                    return 0;
                }
            }
            return 1;
        }
    
        T walk(T n) {
            T c = rand(1, n - 1);
            T x = rand(1, n - 1), y, v, d;
            for (int k = 1;; k <<= 1) {
                y = x, v = 1;
                for (int i = 1; i <= k; i ++) {
                    x = (qmul(x, x, n) + c) % n;
                    v = qmul(v, x - y + n, n);
                    if (i % 127 == 0 || i == k) {
                        d = std::gcd(v, n);
                        if (d > 1) return d;
                    }
                }
            }
        }
        // 质因数分解 Pollard-Rho
        auto primeFactor(T n) {
            std::map<T, int> buc;
            std::function<void(T)> solve = [&] (T n) {
                if (n == 1) {
                    return;
                }
                if (isPrime(n)) {
                    buc[n] ++;
                    return;
                }
                T d = 0;
                while (d = walk(n), d == n);
                solve(d), solve(n / d);
            };
            solve(n);
            return std::vector<std::pair<T, int>>(buc.begin(), buc.end());
        }
    };
    
    // primeTools<int, [] (int a, int b, int p) { return 1ll * a * b % p; }> mrpr;
    // primeTools<i64, [] (i64 a, i64 b, i64 p) { return i128(a) * b % p; }> mrpr;
    // primeTools<i64, [] (i64 a, i64 b, i64 p) {
    //     i64 c = static_cast<long double>(a) * b / p + 1e-8;
    //     i64 ans = a * b - c * p;
    //     if (ans < 0) ans += p;
    //     if (ans >= p) ans -= p;
    //     return ans;
    // }> mrpr;

    0x34 数学 初等数论-约数

    约数

    整除:设 d,n∈Zd, n \in \mathbb{Z} 且 d≠0d \neq 0,如果 ∃q∈Z\exists q \in \mathbb{Z} 使得 qd=nqd = n,那么称 dd 整除 nn(记作 d∣nd \mid n)。

    整除的简单性质:

    • a∣b∧b∣c⟹a∣ca \mid b \land b \mid c \Longrightarrow a\mid c。
    • a∣b∧a∣c⟹∀x,y∈Z,a∣(xb+yc)a \mid b \land a \mid c \Longrightarrow \forall x, y \in \mathbb{Z}, a \mid (xb + yc)。
    • 设 m≠0m \neq 0,则 a∣b⟹ma∣mba \mid b \Longrightarrow ma \mid mb。
    • 设 gcd⁡(a,m)=1\gcd(a, m) = 1,则 a∣mb⟹a∣ba \mid mb \Longrightarrow a\mid b。

    约数个数:

    • nn 的约数个数必定不超过 2n2\sqrt{n}。实际上很难达到该上界,可以简单认为在 106∼101810^6 \sim 10^{18} 范围内为 O(n3)\mathcal{O}(\sqrt[3]{n}) 级别。
    • 1∼n1\sim n 的约数个数总和为 O(nlog⁡n)\mathcal{O}(n \log n) 级别。

    最大公约数与最小公倍数

    最大公约数:最大的公共约数(Greatest Common Divisor,简写 GCD)。

    最小公倍数:最小的公共倍数(Least Common Multiple,简写 LCM)。

    唯一分解角度下的 gcd 与 lcm:设 a=p1c1p2c2…a = p_1^{c_1}p_2^{c_2}\dots,b=p1d1p2d2…b = p_1^{d_1}p_2^{d_2} \dots,则有

    gcd⁡(a,b)=p1min⁡(c1,d1)p2min⁡(c2,d2)…lcm(a,b)=p1max⁡(c1,d1)p2max⁡(c2,d2)…\begin{gathered} \gcd(a, b) = p_1^{\min(c_1, d_1)}p_2^{\min(c_2, d_2)} \dots \\ \mathrm{lcm}(a, b) = p_1^{\max(c_1, d_1)}p_2^{\max(c_2, d_2)} \dots \end{gathered}

    在唯一分解角度下,gcd 相当于是对每个指数取 min,lcm 相当于是对每个指数取 max。

    gcd 的简单性质:

    • gcd⁡(a1,…,an)=gcd⁡(∣a1∣,…,∣an∣)\gcd(a_1, \dots, a_n) = \gcd(|a_1|, \dots, |a_n|)。
    • gcd⁡(a,0)=gcd⁡(a,a)=∣a∣\gcd(a, 0) = \gcd(a, a) = |a|。
    • gcd⁡(bq+r,b)=gcd⁡(r,b)\gcd(bq + r, b) = \gcd(r, b)。
    • 设 gcd⁡(a,m)=1\gcd(a, m) = 1,则 gcd⁡(a,mb)=gcd⁡(a,b)\gcd(a, mb) = \gcd(a, b)。
    • gcd⁡(ma1,…,man)=∣m∣gcd⁡(a1,…,an)\gcd(ma_1, \dots, ma_n) = |m| \gcd(a_1, \dots, a_n)。

    lcm 的简单性质:

    • lcm(a1,…,an)=lcm(∣a1∣,…,∣an∣)\mathrm{lcm}(a_1, \dots, a_n) = \mathrm{lcm}(|a_1|, \dots, |a_n|)。
    • lcm(a,1)=lcm(a,a)=∣a∣\mathrm{lcm}(a, 1) = \mathrm{lcm}(a, a) = |a|。
    • lcm(ma1,…,man)=∣m∣lcm⁡(a1,…,an)\mathrm{lcm}(ma_1, \dots, ma_n) = |m| \operatorname{lcm}(a_1, \dots, a_n)。

    gcd 和 lcm 的常见恒等式

    gcd-lcm 恒等式:

    gcd⁡(a,b)lcm⁡(a,b)=ab\gcd(a, b) \operatorname{lcm}(a, b) = ab

    请注意!该式子扩展到三元以上几乎不成立!

    事实上当 n≥3n \geq 3 时,gcd⁡(a1,…,an)lcm⁡(a1,…,an)=a1…an\gcd(a_1, \dots, a_n) \operatorname{lcm}(a_1, \dots, a_n) = a_1\dots a_n 当且仅当 a1,…,ana_1, \dots, a_n 两两互质。

    gcd 和 lcm 的结合律:

    gcd⁡(a,b,c)=gcd⁡(gcd⁡(a,b),c)lcm(a,b,c)=lcm(lcm(a,b),c)\begin{gathered} \gcd(a, b, c) = \gcd(\gcd(a, b), c) \\ \mathrm{lcm}(a, b, c) = \mathrm{lcm}(\mathrm{lcm}(a, b), c) \end{gathered}

    该式子扩展到任意多元仍然成立。

    于是可以使用恒等式 lcm(a,b)=abgcd⁡(a,b)\mathrm{lcm}(a, b) = \frac{ab}{\gcd(a, b)},用来求解 lcm(a,b,c)\mathrm{lcm}(a, b, c),以及 lcm(a1,…,an)\mathrm{lcm}(a_1, \dots, a_n)。

    gcd 对乘法的分配律:

    gcd⁡(a,bc)=gcd⁡(a,b)gcd⁡(agcd⁡(a,b),c)\gcd(a, bc) = \gcd(a, b) \gcd\left(\frac{a}{\gcd(a, b)}, c\right)

    根据对乘法的分配律计算 gcd⁡(a,b1…bn)\gcd(a, b_1\dots b_n)。每次处理 bib_i 时,计算 t=gcd⁡(a,bi)t = \gcd(a, b_i),然后将 aa 除以 tt(相当于是将已计算的质因数贡献去掉),答案乘以 tt。

    gcd 的差分律:

    gcd⁡(a1,a2,…,an)=gcd⁡(a1,a2−a1,…,an−an−1)\gcd(a_1, a_2, \dots, a_n) = \gcd(a_1, a_2 - a_1, \dots, a_n - a_{n - 1})

    通过差分律,我们可以维护差分数组的 gcd,以实现“区间加”与“区间 gcd”。

    斐波那契数列 gcd 恒等式:

    gcd⁡(Fibn,Fibm)=Fibgcd⁡(n,m)\gcd(\mathrm{Fib}_n, \mathrm{Fib}_m) = \mathrm{Fib}_{\gcd(n, m)}

    幂差 gcd 恒等式:不妨设 a≥ba \geq b,当 gcd⁡(a,b)=1\gcd(a, b) = 1 时,有

    gcd⁡(an−bn,am−bm)=agcd⁡(n,m)−bgcd⁡(n,m)\gcd(a^n - b^n, a^m - b^m) = a^{\gcd(n, m)} - b^{\gcd(n, m)}

    简单推导:

    右边整除左边:可以证明 x−y∣xk−ykx - y \mid x^k - y^k。

    kk 次方差公式:xk−yk=(x−y)(xk−1+xk−2y+⋯+xyk−2+yk−1)x^k - y^k = (x - y)(x^{k - 1} + x^{k - 2}y + \dots + xy^{k - 2} + y^{k - 1})。

    对于 n,mn, m 的公约数 dd 来说,可以证得 ad−bd∣an−bna^d - b^d \mid a^n - b^n 与 ad−bd∣am−bma^d - b^d \mid a^m - b^m。

    于是 ad−bd∣gcd⁡(an−bn,am−bm)a^d - b^d \mid \gcd(a^n - b^n, a^m - b^m)。所以

    agcd⁡(n,m)−bgcd⁡(n,m)∣gcd⁡(an−bn,am−bm)a^{\gcd(n, m)} - b^{\gcd(n, m)} \mid \gcd(a^n - b^n, a^m - b^m)

    左边整除右边:

    “降幂引理”:不妨设 r≥sr \geq s,当 gcd⁡(a,b)=1\gcd(a, b) = 1 时,有

    gcd⁡(ar−br,as−bs)∣ar−s−br−s\gcd(a^r - b^r, a^s - b^s) \mid a^{r - s} - b^{r - s}

    证明:设 dd 为 ar−br,as−bsa^r - b^r, a^s - b^s 的公约数。

    因为 (ar−br)−ar−s(as−bs)=bs(ar−s−br−s)(a^r - b^r) - a^{r - s}(a^s - b^s) = b^s(a^{r - s} - b^{r - s}),可以证得 d∣bs(ar−s−br−s)d \mid b^s(a^{r - s} - b^{r - s});同理可得 d∣as(ar−s−br−s)d \mid a^s(a^{r - s} - b^{r - s})。

    又由于 gcd⁡(a,b)=1\gcd(a, b) = 1,于是 d∣ar−s−br−sd \mid a^{r - s} - b^{r - s},“降幂引理”得证。

    对 gcd⁡(an−bn,am−bm)\gcd(a^n - b^n, a^m - b^m) 反复应用“降幂引理”,过程等价于辗转相除法。所以

    gcd⁡(an−bn,am−bm)∣agcd⁡(n,m)−bgcd⁡(n,m)\gcd(a^n - b^n, a^m - b^m) \mid a^{\gcd(n, m)} - b^{\gcd(n, m)}

    最大公约数常见求法

    已有的轮子:std::gcd(a, b)。

    求法 1:辗转相除法

    (也称之为欧几里得算法)

    对于 ∀a,b∈N\forall a, b \in \mathbb{N} 且 b≠0b \neq 0,有

    gcd⁡(a,b)=gcd⁡(b,a mod b)\gcd(a, b) = \gcd(b, a \bmod b)
    • 当 a<ba < b 时,一次迭代后就会转化为 a≥ba \geq b。
    • 当 a≥ba \geq b 时,由于 a mod b≤a2a \bmod b \leq \frac{a}{2},这样的迭代不超过 2log⁡2a2\log_2 a 次。

    时间复杂度 O(log⁡max⁡(a,b))\mathcal{O}(\log \max(a, b))。

    使用辗转相除法求解斐波那契数列相邻两项的 gcd,会让该算法达到最坏复杂度。

    // 辗转相除法
    int gcd(int a, int b) {
        return b == 0 ? a : gcd(b, a % b);
    }

    求法 2:更相减损术

    对于 ∀a,b∈N\forall a, b \in \mathbb{N},不妨设 a≥ba\geq b,有

    gcd⁡(a,b)=gcd⁡(a,a−b)=gcd⁡(b,a−b)gcd⁡(2a,2b)=2gcd⁡(a,b)\begin{gathered} \gcd(a, b) = \gcd(a, a - b) = \gcd(b, a - b) \\ \gcd(2a, 2b) = 2\gcd(a, b) \end{gathered}
    • 当 a=ba = b 时,gcd⁡(a,b)=a\gcd(a, b) = a。
    • “两个偶数”:gcd⁡(a,b)=2gcd⁡(a2,b2)\gcd(a, b) = 2\gcd(\frac{a}{2}, \frac{b}{2})。
    • “一奇一偶”:不妨设 aa 为偶数,gcd⁡(a,b)=gcd⁡(a2,b)\gcd(a, b) = \gcd(\frac{a}{2}, b)。
    • “两个奇数”:不妨设 a≥ba \geq b,gcd⁡(a,b)=gcd⁡(a−b,b)\gcd(a, b) = \gcd(a - b, b)。

    当至少有一个偶数的时候,每次迭代至少会将 a,ba, b 之一减半。而两个奇数相减会得到偶数。

    时间复杂度 O(log⁡max⁡(a,b))\mathcal{O}(\log \max(a, b))。

    更相减损术常用于计算高精度 gcd(因为“高精度取模”复杂度较高,“高精度减法”以及“高精除低精”复杂度较低)。

    0x34 gcd(更相减损术).cpp:

    // 更相减损术
    int gcd(int a, int b) {
        if (a == b) return a;
        if (a == 0 || b == 0) return a ^ b;
        int az = __builtin_ctz(a), bz = __builtin_ctz(b), z = az < bz ? az : bz, v = 0;
        a >>= az, b >>= bz;
        while (b) {
            v = b - a;
            a = a < b ? a : b;
            b = v < 0 ? -v : v;
            if (b) b >>= __builtin_ctz(b);
        }
        return a << z;
    }

    求法 3:递推

    初值 gcd⁡(i,0)=gcd⁡(0,i)=i\gcd(i, 0) = \gcd(0, i) = i,递推式 gcd⁡(i,j)=gcd⁡(i−j,j)\gcd(i, j) = \gcd(i - j, j)。

    时间复杂度:预处理 O(n2)\mathcal{O}(n^2),查询 O(1)\mathcal{O}(1)。

    for (int i = 0; i <= n; i ++) {
        g[i][0] = g[0][i] = i;
        for (int j = 1; j <= i; j ++) {
            g[i][j] = g[j][i] = g[i - j][j];
        }
    }

    求法 4:基于值域预处理的快速 gcd

    引理:任意正整数 nn 一定可以被拆分成三个正整数 a,b,ca, b, c (a≤b≤ca \leq b \leq c) 的乘积,其中 a,b≤na, b\leq \sqrt{n},且 c≤nc \leq \sqrt{n} 与 c∈Pc \in \mathbb{P} 至少有一个成立。

    证明 1:假设 c>nc > \sqrt{n} 且 c∉Pc \notin \mathbb{P}。因为 c>nc > \sqrt{n} 且 abc=nabc = n,所以 ab≤nab \leq \sqrt{n}。由于 cc 不是质数,设 c=xyc = xy,显然 x,yx, y 不可能同时 >n>\sqrt{n},不妨设 x≤yx \leq y,则必有 x≤nx \leq \sqrt{n}。此时 nn 可以被拆分成 x,ab,yx, ab, y 的乘积。不断对 yy 进行相同的讨论。

    由于数值不断递减,迭代到最后 c≤nc \leq \sqrt{n} 与 c∈Pc \in \mathbb{P} 至少有一个成立。

    证明 2:考虑归纳。当 n=1n = 1 时显然成立。当 n>1n > 1 时,设 pp 为 nn 的最小质因数,设 a′,b′,c′a', b', c' (a′≤b′≤c′a' \leq b' \leq c') 为 np\frac{n}{p} 的一组合法拆分。

    • 当 p≤n4p \leq \sqrt[4]{n} 时,由于 a′≤np3a' \leq \sqrt[3]{\frac{n}{p}},所以 pa′≤np23≤npa' \leq \sqrt[3]{np^2} \leq \sqrt{n}。此时 pa′,b′,c′pa', b', c' 为一组合法拆分。
    • 当 p>n4p > \sqrt[4]{n} 时,假设 a′≥pa' \geq p,则 n=pa′b′c′≥p4>nn = pa'b'c' \geq p^4 > n 矛盾,故 a′<pa' < p。由于 pp 为 nn 的最小质因数,所以 a′=1a' = 1。此时 p,b′,c′p, b', c' 为一组合法拆分。

    预处理:通过线性筛得出 1∼n1 \sim n 所有数的最小质因数。然后根据证明 2,递推得出 1∼n1 \sim n 所有数的合法拆分。对于 i>1i > 1,设 pp 为 ii 的最小质因数,将 ip\frac{i}{p} 的合法拆分中的最小数乘以 pp 即可得到 ii 的合法拆分。最后预处理出所有 0≤x,y≤n0 \leq x, y \leq \sqrt{n} 的 gcd⁡(x,y)\gcd(x, y)。

    查询:当询问 gcd⁡(p,q)\gcd(p, q) 时,根据 gcd 对乘法的分配律,依次考虑 qq 的合法拆分 a,b,ca, b, c,设当前考虑到的数为 xx。

    • 计算 t=gcd⁡(p,x)t = \gcd(p, x),具体地:
      • 若 xx 为合数(此时 x≤nx \leq \sqrt{n}),则 gcd⁡(p,x)=gcd⁡(x,p mod x)\gcd(p, x) = \gcd(x, p \bmod x)。使用预处理的 gcd 值回答即可。
      • 若 xx 为质数,则当且仅当 pp 为 xx 的倍数时 gcd⁡(p,x)=x\gcd(p, x) = x,否则 gcd⁡(p,x)=1\gcd(p, x) = 1。
    • 然后将 pp 除以 tt,答案乘以 tt。

    时间复杂度:预处理 O(n)\mathcal{O}(n),查询 O(1)\mathcal{O}(1)。

    0x34 gcd(基于值域预处理的快速 gcd).cpp:

    // O(n)-O(1) gcd
    struct flashGCD {
        int b;
        std::vector<int> prime, fac;
        std::vector<std::array<int, 3>> s;
        std::vector<std::vector<int>> g;
    
        flashGCD() {}
        flashGCD(int n) {
            init(n);
        }
    
        void init(int n) {
            b = sqrt(n);
            prime.clear(), fac.assign(n + 1, 0);
            s.assign(n + 1, {});
            g.assign(b + 1, std::vector<int>(b + 1, 0));
    
            for (int i = 2; i <= n; i ++) {
                if (!fac[i]) {
                    prime.push_back(i), fac[i] = i;
                }
                for (int p : prime) {
                    if (p > fac[i] || p > n / i) break;
                    fac[i * p] = p;
                }
            }
    
            s[1] = {1, 1, 1};
            for (int i = 2; i <= n; i ++) {
                s[i] = s[i / fac[i]], s[i][0] *= fac[i];
                if (s[i][0] > s[i][1]) {
                    std::swap(s[i][0], s[i][1]);
                }
                if (s[i][1] > s[i][2]) {
                    std::swap(s[i][1], s[i][2]);
                }
            }
    
            for (int i = 0; i <= b; i ++) {
                g[i][0] = g[0][i] = i;
                for (int j = 1; j <= i; j ++) {
                    g[i][j] = g[j][i] = g[i - j][j];
                }
            }
        }
    
        int gcd(int p, int q) {
            if (p == 0 || q == 0) {
                return p ^ q;
            }
            int ans = 1;
            for (int x : s[q]) {
                int t = x <= b ? g[x][p % x] : (p % x ? 1 : x);
                p /= t, ans *= t;
            }
            return ans;
        }
    } fg;

    类欧几里得算法

    类欧几里得算法:用来解决一类形如 ⌊ai+bc⌋\left\lfloor \frac{ai + b}{c} \right\rfloor 结构的求和问题。

    基本模型为

    f(a,b,c,n)=∑i=0n⌊ai+bc⌋f(a, b, c, n) = \sum_{i = 0}^n \left\lfloor \frac{ai + b}{c} \right\rfloor

    首先,可以转化为 0≤a,b<c0 \leq a, b < c 的情况

    f(a,b,c,n)=∑i=0n⌊ai+bc⌋=∑i=0n⌊(⌊ac⌋c+(a mod c))i+(⌊bc⌋c+(b mod c))c⌋=∑i=0n(⌊ac⌋i+⌊bc⌋+⌊(a mod c)i+(b mod c)c⌋)=n(n+1)2⌊ac⌋+(n+1)⌊bc⌋+f(a mod c,b mod c,c,n)\begin{aligned} f(a, b, c, n) & = \sum_{i = 0}^n \left\lfloor \frac{ai + b}{c} \right\rfloor \\ & = \sum_{i = 0}^n \left\lfloor \frac{\left(\left\lfloor \frac{a}{c} \right\rfloor c + (a \bmod c) \right)i + \left(\left\lfloor \frac{b}{c} \right\rfloor c + (b \bmod c)\right)}{c} \right\rfloor \\ & = \sum_{i = 0}^n \left( \left\lfloor \frac{a}{c} \right\rfloor i + \left\lfloor \frac{b}{c} \right\rfloor + \left\lfloor \frac{(a \bmod c) i + (b \bmod c)}{c} \right\rfloor \right) \\ & = \frac{n(n + 1)}{2} \left\lfloor \frac{a}{c} \right\rfloor + (n + 1)\left\lfloor \frac{b}{c} \right\rfloor + f(a \bmod c, b \bmod c, c, n) \end{aligned}

    然后,令 m=⌊an+bc⌋m = \left\lfloor \frac{an + b}{c} \right\rfloor

    f(a,b,c,n)=∑i=0n⌊ai+bc⌋=∑i=0n∑j=0m−1[j<⌊ai+bc⌋]=∑i=0n∑j=0m−1[j+1≤ai+bc]=∑i=0n∑j=0m−1[cj+c−b−1<ai]=∑j=0m−1∑i=0n[⌊cj+c−b−1a⌋<i]=∑j=0m−1(n−⌊cj+c−b−1a⌋)=nm−f(c,c−b−1,a,m−1)\begin{aligned} f(a, b, c, n) & = \sum_{i = 0}^n \left\lfloor \frac{ai + b}{c} \right\rfloor \\ & = \sum_{i = 0}^n \sum_{j = 0}^{m - 1} \left[ j < \left\lfloor \frac{ai + b}{c} \right\rfloor \right] \\ & = \sum_{i = 0}^n \sum_{j = 0}^{m - 1} \left[ j + 1 \leq \frac{ai + b}{c} \right] \\ & = \sum_{i = 0}^n \sum_{j = 0}^{m - 1} \left[ cj + c - b - 1 < ai \right] \\ & = \sum_{j = 0}^{m - 1} \sum_{i = 0}^n \left[ \left\lfloor \frac{cj + c - b - 1}{a} \right\rfloor < i \right] \\ & = \sum_{j = 0}^{m - 1} \left( n - \left\lfloor \frac{cj + c - b - 1}{a} \right\rfloor \right) \\ & = nm - f(c, c - b - 1, a, m - 1) \end{aligned}

    结合这两步操作,二元组 (a,c)→(c,a mod c)(a, c) \to (c, a \bmod c),相当于对 (a,c)(a, c) 进行辗转相除法,故称之为类欧几里得算法。

    时间复杂度 O(log⁡min⁡(a,c))\mathcal{O}(\log \min(a, c))。

    0x34 类欧几里得算法.cpp:

    // 类欧几里得算法(要求 a, b >= 0 以及 c > 0)
    i64 euclid(i64 a, i64 b, i64 c, i64 n) {
        if (a == 0) {
            return (n + 1) * (b / c);
        }
        if (a >= c || b >= c) {
            return euclid(a % c, b % c, c, n) + (n * (n + 1) / 2) * (a / c) + (n + 1) * (b / c);
        }
        i64 m = (a * n + b) / c;
        if (m == 0) {
            return 0;
        }
        return n * m - euclid(c, c - b - 1, a, m - 1);
    }
    // 类欧几里得算法
    i64 euclid_norm(i64 a, i64 b, i64 c, i64 n) {
        if (c < 0) {
            a = -a, b = -b, c = -c;
        }
        i64 sum = 0;
        if (a < 0) {
            i64 t = (a - c + 1) / c;
            a -= t * c, sum += (n * (n + 1) / 2) * t;
        }
        if (b < 0) {
            i64 t = (b - c + 1) / c;
            b -= t * c, sum += (n + 1) * t;
        }
        return euclid(a, b, c, n) + sum;
    }

    0x34 数学 初等数论-取整

    取整

    向下取整:⌊x⌋\lfloor x \rfloor,表示不超过 xx 的最大整数(floor)。

    向上取整:⌈x⌉\lceil x \rceil,表示不小于 xx 的最小整数(ceiling)。

    注意:C++ 中的整数除法结果向零取整,取模结果与被除数同号,与数学中的取整有较大区别。

    取整的简单性质:

    • x−1<⌊x⌋≤xx - 1 < \lfloor x \rfloor \leq x,x≤⌈x⌉<x+1x \leq \lceil x \rceil < x + 1。
    • ⌊−x⌋=−⌈x⌉\lfloor -x \rfloor = - \lceil x \rceil,⌈−x⌉=−⌊x⌋\lceil -x \rceil = - \lfloor x \rfloor。

    取整的常见恒等式

    上下取整的相互转化:n,m∈Zn, m \in \mathbb{Z},m>0m > 0

    ⌈nm⌉=⌊n+m−1m⌋=⌊n−1m⌋+1⌊nm⌋=⌈n−m+1m⌉=⌈n+1m⌉−1\begin{gathered} \left\lceil \frac{n}{m} \right\rceil = \left\lfloor \frac{n + m - 1}{m} \right\rfloor = \left\lfloor \frac{n - 1}{m} \right\rfloor + 1 \\ \left\lfloor \frac{n}{m} \right\rfloor = \left\lceil \frac{n - m + 1}{m} \right\rceil = \left\lceil \frac{n + 1}{m} \right\rceil - 1 \end{gathered}

    上下取整的嵌套恒等式:a,b,c∈N+a, b, c \in \mathbb{N}_+

    ⌊⌊ab⌋c⌋=⌊abc⌋⌈⌈ab⌉c⌉=⌈abc⌉\begin{gathered} \left\lfloor \frac{ \left\lfloor \frac{a}{b} \right\rfloor }{c} \right\rfloor = \left\lfloor \frac{a}{bc} \right\rfloor \\ \left\lceil \frac{ \left\lceil \frac{a}{b} \right\rceil }{c} \right\rceil = \left\lceil \frac{a}{bc} \right\rceil \end{gathered}

    上下取整对加法的恒等式:A,B,C,D∈N+A, B, C, D \in \mathbb{N}_+

    ⌊⌊AB⌋+CD⌋=⌊A+BCBD⌋⌈⌈AB⌉+CD⌉=⌈A+BCBD⌉\begin{gathered} \left\lfloor \frac{ \left\lfloor \frac{A}{B} \right\rfloor + C }{D} \right\rfloor = \left\lfloor \frac{A + BC}{BD} \right\rfloor \\ \left\lceil \frac{ \left\lceil \frac{A}{B} \right\rceil + C }{D} \right\rceil = \left\lceil \frac{A + BC}{BD} \right\rceil \end{gathered}

    数论分块

    也称之为整除分块。

    下取整数论分块

    给出一个正整数 nn,记 DnD_n 表示 ⌊nd⌋\left\lfloor \frac{n}{d} \right\rfloor 所有可能的取值构成的集合,即 Dn={⌊nd⌋∣1≤d≤n}D_n = \{ \left\lfloor \frac{n}{d} \right\rfloor \mid 1 \leq d \leq n \}。

    性质 1:⌊nd⌋\left\lfloor \frac{n}{d} \right\rfloor 的取值不超过 2n2\sqrt{n} 种,即 ∣Dn∣≤2n|D_n| \leq 2\sqrt{n}。

    简单推导:

    • 当 d≤nd \leq \sqrt{n} 时,因为 dd 的取值不超过 n\sqrt{n} 种,所以此时 ⌊nd⌋\left\lfloor \frac{n}{d} \right\rfloor 的取值不超过 n\sqrt{n} 种。
    • 当 d>nd > \sqrt{n} 时,因为 ⌊nd⌋≤n\left\lfloor \frac{n}{d} \right\rfloor \leq \sqrt{n},所以此时 ⌊nd⌋\left\lfloor \frac{n}{d} \right\rfloor 的取值不超过 n\sqrt{n} 种。

    性质 2:若 m∈Dnm \in D_n,则 Dm⊆DnD_m \subseteq D_n。

    简单推导:设 m=⌊nk⌋m = \left\lfloor \frac{n}{k} \right\rfloor,此时对于任意 d∈N+d \in \mathbb{N}_+

    ⌊md⌋=⌊⌊nk⌋d⌋=⌊nkd⌋∈Dn\left\lfloor \frac{m}{d} \right\rfloor = \left\lfloor \frac{\left\lfloor \frac{n}{k} \right\rfloor}{d} \right\rfloor = \left\lfloor \frac{n}{kd} \right\rfloor \in D_n

    这意味着,如果我们想要递归地应用数论分块(类似杜教筛),在计算过程中涉及到的取值集合均为 DnD_n。

    下取整数论分块:快速地划分出 ⌊nd⌋\left\lfloor \frac{n}{d} \right\rfloor 取值相同的所有区间。

    由于函数 nx\frac{n}{x} 在区间 (0,+∞)(0, +\infty) 上单调递减,所以 ⌊nx⌋\left\lfloor \frac{n}{x} \right\rfloor 取值相同的所有自变量 xx 构成一段连续的区间。并且由上述分析,这样的区间不超过 2n2\sqrt{n} 个。

    对于任意 ii (1≤i≤n1 \leq i \leq n),需要找到一个最大的 jj (i≤j≤ni \leq j \leq n) 满足 ⌊ni⌋=⌊nj⌋\left\lfloor \frac{n}{i} \right\rfloor = \left\lfloor \frac{n}{j} \right\rfloor。由不等式 ⌊ni⌋≤nj\left\lfloor \frac{n}{i} \right\rfloor \leq \frac{n}{j} 可得 j=⌊n⌊ni⌋⌋\boldsymbol{j = \left\lfloor \frac{n}{\left\lfloor \frac{n}{i} \right\rfloor} \right\rfloor}。

    根据该公式,我们就可以根据区间的左端点计算出右端点。于是依次遍历所有区间即可。

    // h 表示 x 的上界
    for (int x = 1, nx; x <= h; x = nx + 1) {
        nx = h;
        if (x <= n) {
            chmin(nx, n / (n / x));
        }
        // 区间 [x, nx] 内:下取整的值均为 n/x
    }

    By the way:数论分块套数论分块的时间复杂度为 O(n34)\mathcal{O}(n^{\frac{3}{4}})。

    上取整数论分块

    上取整数论分块:快速地找出 ⌈nd⌉\lceil \frac{n}{d} \rceil 取值相同的所有区间。

    由恒等式 ⌈nm⌉=⌊n−1m⌋+1\left\lceil \frac{n}{m} \right\rceil = \left\lfloor \frac{n - 1}{m} \right\rfloor + 1 可知,nn 的上取整数论分块与 n−1n - 1 的下取整数论分块,分出的区间是一样的。

    于是套用 n−1n - 1 的下取整数论分块即可,注意 d≥nd \geq n 的特殊情况。

    // h 表示 x 的上界
    for (int x = 1, nx; x <= h; x = nx + 1) {
        nx = h;
        if (x < n) {
            chmin(nx, (n - 1) / ((n - 1) / x));
        }
        // 区间 [x, nx] 内:上取整的值均为 (n-1)/x+1
    }

    多维数论分块

    二维数论分块:快速地找出 ⌊nd⌋,⌊md⌋\left\lfloor \frac{n}{d} \right\rfloor, \left\lfloor \frac{m}{d} \right\rfloor 取值均相同的所有区间。

    显然,这样的区间不超过 2n+2m2\sqrt{n} + 2\sqrt{m} 个。

    对于任意 ii,需要找到一个最大的 jj 满足 ⌊ni⌋=⌊nj⌋,⌊mi⌋=⌊mj⌋\left\lfloor \frac{n}{i} \right\rfloor = \left\lfloor \frac{n}{j} \right\rfloor, \left\lfloor \frac{m}{i} \right\rfloor = \left\lfloor \frac{m}{j} \right\rfloor。则有 j=min⁡{⌊n⌊ni⌋⌋,⌊m⌊mi⌋⌋}\boldsymbol{j = \min\left\{ \left\lfloor \frac{n}{ \left\lfloor \frac{n}{i} \right\rfloor } \right\rfloor, \left\lfloor \frac{m}{ \left\lfloor \frac{m}{i} \right\rfloor } \right\rfloor \right\}}。

    扩展到多维也是一样。

    // h 表示 x 的上界
    for (int x = 1, nx; x <= h; x = nx + 1) {
        nx = h;
        if (x <= n) {
            chmin(nx, n / (n / x));
        }
        if (x <= m) {
            chmin(nx, m / (m / x));
        }
        // 区间 [x, nx] 内:n, m 对 x 下取整的值分别为 n/x, m/x
    }

    积性函数与狄利克雷卷积

    积性函数:若数论函数 f(n)f(n),对于任意互质正整数 x,yx, y,都有 f(xy)=f(x)f(y)f(xy) = f(x)f(y),则称 f(n)f(n) 为积性函数。

    完全积性函数:若数论函数 f(n)f(n),对于任意正整数 x,yx, y,都有 f(xy)=f(x)f(y)f(xy) = f(x)f(y),则称 f(n)f(n) 为完全积性函数。

    积性函数的简单性质:

    • 对于任意积性函数 f(x)f(x)(除了恒为 00 的函数),有 f(1)=1f(1) = 1。

    • 对于任意积性函数 f(x),g(x)f(x), g(x),以下的函数仍为积性函数

      f(xp)fp(x)f(x)g(x)∑d∣xf(d)g(xd)\begin{gathered} f(x^p) \\ f^p(x) \\ f(x)g(x) \\ \sum_{d \mid x} f(d)g\left( \frac{x}{d} \right) \end{gathered}
    • 对于任意积性函数 f(x)f(x),将 xx 唯一分解成 x=p1c1p2c2…ptctx = p_1^{c_1}p_2^{c_2}\dots p_t^{c_t},有 f(x)=∏i=1tf(pici)f(x) = \prod_{i = 1}^t f(p_i^{c_i})。

    常见积性函数(及性质)

    单位函数(完全积性)

    ϵ(n)=[n=1]\epsilon(n) = [n = 1]

    恒等函数(完全积性)

    IDk(n)=nk\mathrm{ID}_k(n) = n^k

    当 k=1k = 1 时,亦可简写为 ID(n)=n\mathrm{ID}(n) = n。

    常数函数(完全积性)

    1(n)=11(n) = 1

    约数函数(积性)

    约数函数:

    σk(n)=∑d∣ndk\sigma_k(n) = \sum_{d \mid n} d^k

    当 k=0k = 0 时,σ0(n)\sigma_0(n) 表示 nn 的约数个数函数。

    约数个数函数的前缀和:

    ∑i=1nσ0(i)=∑i=1n⌊ni⌋\sum_{i = 1}^n \sigma_0(i) = \sum_{i = 1}^n \left\lfloor \frac{n}{i} \right\rfloor

    乘积的约数个数函数:

    σ0(ij)=∑x∣i∑y∣j[gcd⁡(x,y)=1]σ0(ijk)=∑a∣i∑b∣j∑c∣k[gcd⁡(a,b)=gcd⁡(b,c)=gcd⁡(a,c)=1]\begin{gathered} \sigma_0(ij) = \sum_{x \mid i} \sum_{y \mid j} [\gcd(x, y) = 1] \\ \sigma_0(ijk) = \sum_{a \mid i} \sum_{b \mid j} \sum_{c \mid k} [\gcd(a, b) = \gcd(b, c) = \gcd(a, c) = 1] \end{gathered}

    简单推导(仅证二维):从唯一分解的角度,对每个质因子 pp 单独考虑。pp 在 (x,y)(x, y) 中的出现情况数,为 i,ji, j 中质因子 pp 的个数之和再加 11。将所有质因子 pp 的贡献相乘,这正是 σ0(ij)\sigma_0(ij) 的表达式。

    可以扩展至更多维。

    欧拉函数(积性)

    欧拉函数:φ(n)\varphi(n),表示 1∼n1 \sim n 中与 nn 互质的数的个数。将 nn 唯一分解成 n=p1c1p2c2…ptctn = p_1^{c_1}p_2^{c_2}\dots p_t^{c_t},则欧拉函数为

    φ(n)=n∏i=1t(1−1pi)\varphi(n) = n \prod_{i = 1}^t (1 - \frac{1}{p_i})

    乘积的欧拉函数:

    φ(ij)=φ(i)φ(j)gcd⁡(i,j)φ(gcd⁡(i,j))\varphi(ij) = \frac{\varphi(i) \varphi(j) \gcd(i, j)}{\varphi(\gcd(i, j))}

    简单推导:设 P(n)P(n) 表示 nn 的质因数集合,则有 P(ij)=P(i)∪P(j)P(ij) = P(i) \cup P(j) 与 P(gcd⁡(i,j))=P(i)∩P(j)P(\gcd(i, j)) = P(i) \cap P(j)。

    由容斥原理得

    ∏p∣ij(1−1p)=∏p∣i(1−1p)∏p∣j(1−1p)∏p∣gcd⁡(i,j)(1−1p)  ⟺  φ(ij)ij=φ(i)iφ(j)jφ(gcd⁡(i,j))gcd⁡(i,j)\prod_{p \mid ij} \left(1 - \frac{1}{p}\right) = \frac{\prod_{p \mid i} \left(1 - \frac{1}{p}\right) \prod_{p \mid j} \left(1 - \frac{1}{p}\right)}{\prod_{p \mid \gcd(i, j)} \left(1 - \frac{1}{p}\right)} \iff \frac{\varphi(ij)}{ij} = \frac{ \frac{\varphi(i)}{i} \frac{\varphi(j)}{j} }{\frac{\varphi(\gcd(i, j))}{\gcd(i, j)}}

    莫比乌斯函数(积性)

    莫比乌斯函数:μ(n)\mu(n),将 nn 唯一分解成 n=p1c1p2c2…ptctn = p_1^{c_1}p_2^{c_2}\dots p_t^{c_t},则莫比乌斯函数有如下的定义

    μ(n)={(−1)t∀i∈[1,t],ci=10∃i∈[1,t],ci>1\mu(n) = \begin{cases} (-1)^t & \forall i\in[1, t], c_i = 1 \\ 0 & \exists i\in[1, t], c_i > 1 \end{cases}

    特别地,μ(1)=1\mu(1) = 1。

    莫比乌斯函数的平方:

    μ2(n)=∑d2∣nμ(d)\mu^2(n) = \sum_{d^2 \mid n} \mu(d)

    简单推导:记 m=∏pi⌊ci/2⌋m = \prod p_i^{\left\lfloor c_i / 2 \right\rfloor},则 d2∣n  ⟺  d∣md^2 \mid n \iff d \mid m,由 ∑d∣mμ(d)=[m=1]\sum_{d \mid m}\mu(d) = [m = 1] 可证。

    线性筛筛积性函数

    对于积性函数 f(x)f(x),若质数幂的函数值 f(pc)f(p^c) 便于求出,则 f(x)f(x) 的前 nn 项函数值可以通过线性筛得出。

    具体地,记 lowi\mathrm{low}_i 表示:设 ii 的最小质因子为 p1p_1,其次数为 c1c_1,则 lowi=p1c1\mathrm{low}_i = p_1^{c_1}。

    在线性筛的过程中,额外进行如下的维护

    • 维护 lowi\mathrm{low}_i 数组。
    • 每当筛出一个质数 pp,就将 f(p),f(p2),…,f(pc)f(p), f(p^2), \dots, f(p^c) 全都求出来。
    • 其余满足 i≠lowii \neq\mathrm{low}_i 的 ii,使用递推式 f(i)=f(lowi)×f(ilowi)f(i) = f(\mathrm{low}_i) \times f\left(\frac{i}{\mathrm{low}_i}\right) 计算函数值。

    0x34 线性筛筛积性函数.cpp:

    // 线性筛筛积性函数
    int primeCount, prime[MaxV], low[MaxV];
    int f[MaxV];
    void sieve(int n) {
        f[1] = 1;
        for (int i = 2; i <= n; i ++) {
            if (!low[i]) {
                prime[++ primeCount] = i, low[i] = i;
                for (i64 v = i, c = 1; v <= n; v *= i, c ++) {
                    // 计算 f[v]
                }
            }
            for (int j = 1; j <= primeCount; j ++) {
                if (prime[j] > n / i) break;
                low[i * prime[j]] = i % prime[j] ? prime[j] : low[i] * prime[j];
                
                if (i % prime[j] == 0) break;
            }
            if (low[i] < i) {
                f[i] = f[low[i]] * f[i / low[i]];
            }
        }
    }

    狄利克雷卷积

    狄利克雷卷积:对于两个数论函数 f,gf, g,定义 f,gf, g 的狄利克雷卷积为

    (f∗g)(x)=∑d∣xf(d)g(xd)(f \ast g)(x) = \sum_{d \mid x} f(d)g\left( \frac{x}{d} \right)

    狄利克雷卷积的简单性质:

    • 交换律:f∗g=g∗ff \ast g = g \ast f。
    • 结合律:(f∗g)∗h=f∗(g∗h)(f \ast g) \ast h = f \ast (g \ast h)。
    • 分配律:f∗(g+h)=f∗g+f∗hf \ast (g + h) = f \ast g + f \ast h。
    • 单位元:f∗ϵ=ϵ∗f=ff \ast \epsilon = \epsilon \ast f = f,因此 ϵ\epsilon 又被称为狄利克雷卷积的单位元。

    常见狄利克雷卷积式

    式 1

    ϵ=μ∗1  ⟺  ∑d∣nμ(d)=[n=1]\boldsymbol{\epsilon = \mu \ast 1 \iff \sum_{d \mid n} \mu(d) = [n = 1]}

    简单推导:由积性函数的简单性质可知,关于 nn 的函数 f(n)=∑d∣nμ(d)f(n) = \sum_{d \mid n} \mu(d) 为积性函数。

    • 当 n=1n = 1 时,等式成立。
    • 当 n>1n > 1 时,将 nn 唯一分解成 n=p1c1p2c2…ptctn = p_1^{c_1}p_2^{c_2}\dots p_t^{c_t},则有
      f(n)=∏i=1tf(pici)=∏i=1t(∑j=0ciμ(pij))=∏i=1t(μ(1)+μ(pi))=0\begin{aligned} f(n) & = \prod_{i = 1}^t f(p_i^{c_i}) \\ & = \prod_{i = 1}^t \left( \sum_{j = 0}^{c_i} \mu(p_i^j) \right) \\ & = \prod_{i = 1}^t \left( \mu(1) + \mu(p_i) \right) \\ & = 0 \end{aligned}

    综上,∑d∣nμ(d)=[n=1]\sum_{d \mid n} \mu(d) = [n = 1]。

    式 2

    ID=φ∗1  ⟺  ∑d∣nφ(d)=n\boldsymbol{\mathrm{ID} = \varphi \ast 1 \iff \sum_{d \mid n} \varphi(d) = n}

    简单推导:由积性函数的简单性质可知,关于 nn 的函数 f(n)=∑d∣nφ(d)f(n) = \sum_{d \mid n} \varphi(d) 为积性函数。

    • 当 n=1n = 1 时,等式成立。
    • 当 n>1n > 1 时,将 nn 唯一分解成 n=p1c1p2c2…ptctn = p_1^{c_1}p_2^{c_2}\dots p_t^{c_t},则有
      f(n)=∏i=1tf(pici)=∏i=1t(∑j=0ciφ(pij))=∏i=1t(1+∑j=1ci(pij−pij−1))=∏i=1tpici=n\begin{aligned} f(n) & = \prod_{i = 1}^t f(p_i^{c_i}) \\ & = \prod_{i = 1}^t \left( \sum_{j = 0}^{c_i} \varphi(p_i^j) \right) \\ & = \prod_{i = 1}^t \left( 1 + \sum_{j = 1}^{c_i}(p_i^{j} - p_i^{j - 1}) \right) \\ & = \prod_{i = 1}^t p_i^{c_i} \\ & = n \end{aligned}

    综上,∑d∣nφ(d)=n\sum_{d \mid n} \varphi(d) = n。

    式 3

    φ=μ∗ID  ⟺  φ(n)=∑d∣ndμ(nd)\boldsymbol{\varphi = \mu \ast \mathrm{ID} \iff \varphi(n) = \sum_{d \mid n} d\mu\left( \frac{n}{d} \right)}

    简单推导:

    φ∗1=ID⟹φ∗1∗μ=ID∗μ⟹φ∗ϵ=ID∗μ⟹φ=ID∗μ\begin{aligned} \varphi \ast 1 = \mathrm{ID} & \Longrightarrow \varphi \ast 1 \ast \mu = \mathrm{ID} \ast \mu \\ & \Longrightarrow \varphi \ast \epsilon = \mathrm{ID} \ast \mu \\ & \Longrightarrow \varphi = \mathrm{ID} \ast \mu \end{aligned}

    杜教筛

    杜教筛:用于在 O(n23)\mathcal{O}(n^{\frac{2}{3}}) 时间内求解一类数论函数 f(x)f(x) 的前缀和。

    • f(x)f(x) 为积性函数。
    • 存在辅助函数 g(x)g(x),满足函数 f∗gf \ast g 与 gg 的前缀和便于求出。

    记 S(n)=∑i=1nf(i)S(n) = \sum_{i = 1}^n f(i)。取杜教筛中的辅助函数 g(x)g(x),则有

    ∑i=1n(f∗g)(i)=∑i=1n∑d∣ig(d)f(id)=∑i=1ng(i)∑j=1⌊ni⌋f(j)=∑i=1ng(i)S(⌊ni⌋)\begin{aligned} \sum_{i = 1}^n (f \ast g)(i) & = \sum_{i = 1}^n \sum_{d \mid i} g(d)f\left( \frac{i}{d} \right) \\ & = \sum_{i = 1}^n g(i) \sum_{j = 1}^{\left\lfloor \frac{n}{i} \right\rfloor} f(j) \\ & = \sum_{i = 1}^n g(i) S\left( \left\lfloor \frac{n}{i} \right\rfloor \right) \end{aligned}

    移项得

    g(1)S(n)=∑i=1n(f∗g)(i)−∑i=2ng(i)S(⌊ni⌋)g(1)S(n) = \sum_{i = 1}^n (f \ast g)(i) - \sum_{i = 2}^n g(i)S\left( \left\lfloor \frac{n}{i} \right\rfloor \right)

    此时得到了一个 S(n)S(n) 关于 S(⌊ni⌋)S\left( \left\lfloor \frac{n}{i} \right\rfloor \right) 的递推式。若函数 f∗gf \ast g 与 gg 的前缀和便于求出,就可以使用数论分块处理该式。因此找到一个合适的辅助函数 gg 是杜教筛的关键。

    杜教筛的时间复杂度分析:

    由数论分块的性质,对于 m∈Dnm \in D_n,有 Dm⊆DnD_m \subseteq D_n。于是我们需要使用记忆化保证杜教筛的复杂度,使用记忆化以后,只需要对所有的 k∈Dnk \in D_n 计算一次 S(k)S(k) 即可。

    假设函数 f∗gf \ast g 与 gg 的前缀和均可 O(1)\mathcal{O}(1) 求出,设计算 S(n)S(n) 的时间复杂度为 T(n)T(n),则有

    T(n)=∑k∈DnO(k)=O(n)+∑i=1nO(i)+∑i=2nO(ni)=O(∫0n(x+nx)dx)=O(n34)\begin{aligned} T(n) & = \sum\limits_{k \in D_n} \mathcal{O}(\sqrt{k}) \\ & = \mathcal{O}(\sqrt{n}) + \sum_{i = 1}^{\sqrt{n}}\mathcal{O}(\sqrt{i}) + \sum_{i = 2}^{\sqrt{n}} \mathcal{O}\left( \sqrt{\frac{n}{i}} \right) \\ & = \mathcal{O}\left( \int_0^{\sqrt{n}} \left( \sqrt{x} + \sqrt{\frac{n}{x}} \right) \mathrm{dx} \right) \\ & = \mathcal{O}(n^{\frac{3}{4}}) \end{aligned}

    进一步优化,我们预处理出数论函数 f(x)f(x) 的前 mm 项(其中 m≥nm \geq \sqrt{n}),并预处理出其前缀和。设预处理的时间复杂度为 T0(m)T_0(m),则有

    T(n)=T0(m)+∑k∈Dn,k>mO(k)=T0(m)+∑i=1⌊nm⌋O(ni)=O(T0(m)+∫0nmnxdx)=O(T0(m)+nm)\begin{aligned} T(n) & = T_0(m) + \sum_{k \in D_n, k > m} \mathcal{O}(\sqrt{k}) \\ & = T_0(m) + \sum_{i = 1}^{\left\lfloor \frac{n}{m} \right\rfloor} \mathcal{O}\left(\sqrt{\frac{n}{i}}\right) \\ & = \mathcal{O}\left(T_0(m) + \int_0^{\frac{n}{m}} \sqrt{\frac{n}{x}} \mathrm{dx}\right) \\ & = \mathcal{O}\left(T_0(m) + \frac{n}{\sqrt{m}} \right) \end{aligned}

    通常我们使用线性筛预处理 f(x)f(x) 的前 mm 项,此时 T0(m)=O(m)T_0(m) = \mathcal{O}(m)。由均值不等式,取 m=O(n23)m = \mathcal{O}(n^{\frac{2}{3}}) 可得杜教筛的最优时间复杂度 O(n23)\mathcal{O}(n^{\frac{2}{3}})。

    总结:预处理出 f(x)f(x) 的前 n23n^{\frac{2}{3}} 项及其前缀和,使用关于 S(⌊ni⌋)S\left( \left\lfloor \frac{n}{i} \right\rfloor \right) 的递推式求解 S(n)S(n),并使用 std::map 记忆化。

    0x34 杜教筛.cpp:

    namespace du {
        const int V = 1e6; // 预处理的范围(需根据实际问题调整)
        const int MaxV = V + 10;
    
        int primeCount, prime[MaxV], low[MaxV];
        int f[MaxV];
    
        i64 f1[MaxV];
        std::map<int, i64> f2;
    
        void init(int n = V) {
            f[1] = 1;
            for (int i = 2; i <= n; i ++) {
                if (!low[i]) {
                    prime[++ primeCount] = i, low[i] = i;
                    for (i64 v = i, c = 1; v <= n; v *= i, c ++) {
                        // 计算 f[v]
                    }
                }
                for (int j = 1; j <= primeCount; j ++) {
                    if (prime[j] > n / i) break;
                    low[i * prime[j]] = i % prime[j] ? prime[j] : low[i] * prime[j];
    
                    if (i % prime[j] == 0) break;
                }
                if (low[i] < i) {
                    f[i] = f[low[i]] * f[i / low[i]];
                }
            }
    
            for (int i = 1; i <= n; i ++) {
                f1[i] = f1[i - 1] + f[i];
            }
        }
    
        i64 fSum(int n) {
            if (n <= V) return f1[n];
            if (f2.contains(n)) return f2[n];
    
            i64 ans = 0; // 初始计算函数 f*g 第 1~n 项的和
            for (int x = 2, nx; x <= n; x = nx + 1) {
                nx = n / (n / x);
                i64 sum = 0; // 计算函数 g 第 x~nx 项的和
                ans -= sum * fSum(n / x);
            }
            return f2[n] = ans;
        }
    }

    杜教筛求莫比乌斯函数与欧拉函数前缀和:

    给莫比乌斯函数选择的辅助函数为 1(n)=11(n) = 1,由于 μ∗1=ϵ\mu \ast 1 = \epsilon,函数 ϵ\epsilon 与 11 的前缀和均便于求出。代入杜教筛公式得

    S(n)=1−∑i=2nS(⌊ni⌋)S(n) = 1 - \sum_{i = 2}^n S\left( \left\lfloor \frac{n}{i} \right\rfloor \right)

    给欧拉函数选择的辅助函数为 1(n)=11(n) = 1,由于 φ∗1=ID\varphi \ast 1 = \mathrm{ID},函数 ID\mathrm{ID} 与 11 的前缀和均便于求出。代入杜教筛公式得

    S(n)=n(n+1)2−∑i=2nS(⌊ni⌋)S(n) = \frac{n(n + 1)}{2} - \sum_{i = 2}^n S\left( \left\lfloor \frac{n}{i} \right\rfloor \right)

    求欧拉函数前缀和,更简便的方法是莫比乌斯反演,注意到 ∑i=1nφ(i)=∑1≤i≤j≤n[gcd⁡(i,j)=1]\sum_{i = 1}^n \varphi(i) = \sum_{1 \leq i \leq j \leq n} [\gcd(i, j) = 1]。

    而 ∑i=1n∑j=1n[gcd⁡(i,j)=1]=∑d=1nμ(d)⌊nd⌋2\sum_{i = 1}^n \sum_{j = 1}^n [\gcd(i, j) = 1] = \sum_{d = 1}^n \mu(d)\left\lfloor \frac{n}{d} \right\rfloor^2,使用莫比乌斯函数前缀和配合数论分块处理该式即可。

    Min_25 筛

    待填坑。

    0x34 数学 初等数论-同余

    同余

    带余除法:对于任意 n,m∈Zn, m \in \mathbb{Z} 且 m≠0m \neq 0,存在唯一的 q,r∈Zq, r \in \mathbb{Z},使得 n=qm+rn = qm + r (0≤r<∣m∣0 \leq r < |m|)。

    当 m>0m > 0 时,记 q=⌊nm⌋q = \left\lfloor \frac{n}{m} \right\rfloor,r=n mod mr = n \bmod m。

    同余:若 a mod m=b mod ma \bmod m = b \bmod m,则称 a,ba, b 模 mm 同余,记作 a≡b(modm)a \equiv b \pmod m。

    同余的简单性质:

    • 若 a≡b(modm),c≡d(modm)a \equiv b \pmod m, c \equiv d \pmod m,则
      • a+c≡b+d(modm)a + c \equiv b + d \pmod m。
      • ac≡bd(modm)ac \equiv bd \pmod m。
    • ac≡bc(modm)⟹a≡b(modmgcd⁡(c,m))ac \equiv bc \pmod m \Longrightarrow a \equiv b \pmod{\frac{m}{\gcd(c, m)}}。

    同余类:集合 a‾={a+km∣k∈Z}\overline{a} = \{a + km \mid k \in \mathbb{Z}\}(其中 a∈[0,m−1]a\in [0, m - 1])中的所有数模 mm 同余,余数均为 aa,该集合称为一个模 mm 的同余类。

    (完全)剩余系:mm 的完全剩余系包含 mm 个元素 0‾,1‾,…,m−1‾\overline{0}, \overline{1}, \dots, \overline{m - 1}。

    (简化)剩余系:mm 的简化剩余系包含 φ(m)\varphi(m) 个元素,1∼m1 \sim m 中与 mm 互质的数代表的同余类构成该剩余系。

    剩余系的简单性质:

    • 对于 i=0,1,…,m−1i = 0, 1, \dots, m - 1,ia mod mia \bmod m 两两不同当且仅当 gcd⁡(a,m)=1\gcd(a, m) = 1。
    • 对于与 mm 互质的整数 i,ji, j,ij mod mij \bmod m 仍然与 mm 互质。

    费马小定理与欧拉定理

    费马小定理:设 pp 是质数,对于任意整数 aa(aa 不能是 pp 的倍数),满足 ap−1≡1(modp)a^{p - 1} \equiv 1 \pmod p。

    另一个形式:设 pp 是质数。对于任意整数 aa,满足 ap≡a(modp)a^p \equiv a \pmod p。

    简单推导:由于 pp 是质数且 p∤ap \nmid a,对于 i=0,1,…,p−1i = 0, 1, \dots, p - 1,ia mod pia \bmod p 两两不同。

    因此 {ia mod p}\{ ia \bmod p \} 也构成 0∼p−10 \sim p - 1 的排列。所以

    ∏i=1p−1(ia mod p)=∏i=1p−1i\prod_{i = 1}^{p - 1}(ia \bmod p) = \prod_{i = 1}^{p - 1} i

    又由于

    ∏i=1p−1ia≡ap−1∏i=1p−1i(modp)\prod_{i = 1}^{p - 1}ia \equiv a^{p - 1}\prod_{i = 1}^{p - 1} i \pmod p

    所以

    (ap−1−1)∏i=1p−1i≡0(modp)(a^{p - 1} - 1)\prod_{i = 1}^{p - 1}i \equiv 0 \pmod p

    由于 1,2,…,p−11, 2, \dots, p - 1 均不是 pp 的倍数,所以 ap−1−1a^{p - 1} - 1 是 pp 的倍数。即 ap−1≡1(modp)a^{p - 1}\equiv 1 \pmod p。

    By the way:费马小定理的逆命题并不成立。

    即使对于所有与 pp 互质的整数 aa 均满足 ap−1≡1(modp)a^{p - 1} \equiv 1 \pmod p,pp 也不一定是质数。

    欧拉定理:设整数 m>0m > 0,对于任意满足 gcd⁡(a,m)=1\gcd(a, m) = 1 的整数 aa,满足 aφ(m)≡1(modm)a^{\varphi(m)} \equiv 1 \pmod m。

    简单推导:设 RR 表示 1∼m1 \sim m 中与 mm 互质的数构成的集合。已知 a∈Ra\in R,对于所有 RR 中的元素 rr,ra mod mra \bmod m 仍然属于 RR 且两两不同。所以

    ∏r∈R(ra mod m)=∏r∈Rr\prod_{r \in R} (ra \bmod m) = \prod_{r \in R} r

    又由于

    ∏r∈Rra≡aφ(m)∏r∈Rr(modm)\prod_{r \in R} ra \equiv a^{\varphi(m)} \prod_{r \in R} r \pmod m

    所以

    (aφ(m)−1)∏r∈Rr≡0(modm)(a^{\varphi(m)} - 1) \prod_{r \in R} r \equiv 0 \pmod m

    由于每个 r∈Rr\in R 均与 mm 互质,所以 aφ(m)≡1(modm)a^{\varphi(m)} \equiv 1 \pmod m。

    扩展欧拉定理:设整数 m>0m > 0,对于任意整数 a,ba, b (b≥0b \geq 0),有

    ab≡{ab mod φ(m)gcd⁡(a,m)=1abgcd⁡(a,m)≠1,b<φ(m)ab mod φ(m)+φ(m)gcd⁡(a,m)≠1,b≥φ(m)(modm)a^b \equiv \begin{cases} a^{b \bmod \varphi(m)} & \gcd(a, m) = 1 \\ a^b & \gcd(a, m) \neq 1, b < \varphi(m) \\ a^{b \bmod \varphi(m) + \varphi(m)} & \gcd(a, m) \neq 1, b \geq \varphi(m) \end{cases} \pmod m

    直观理解:考虑 ab mod ma^b \bmod m 的循环情况。当 gcd⁡(a,m)=1\gcd(a, m) = 1 时,该循环为纯循环;当 gcd⁡(a,m)≠1\gcd(a, m) \neq 1 时,该循环为混循环(类似 ρ\rho 形),需要对尾巴和环形分别讨论。

    通常使用扩展欧拉定理,以达到降幂的效果。

    模意义下逆元

    模意义下逆元:对于非零整数 a,ma, m,如果存在整数 bb 使得 ab≡1(modm)ab \equiv 1 \pmod m,则称 bb 为 aa 在模 mm 意义下的逆元。记作 a−1 mod ma^{-1} \bmod m。

    模质数意义下逆元

    当模数 pp 为质数时,对于任意整数 aa(aa 不能是 pp 的倍数),有

    a×ap−2≡1(modp)a \times a^{p - 2} \equiv 1 \pmod p

    此时,ap−2 mod pa^{p - 2} \bmod p 即为 aa 在模 pp 意义下的逆元。

    单个逆元的求解

    若要求解 aa 在模 mm 意义下的逆元,相当于是要求解线性同余方程 ax≡1(modm)ax \equiv 1 \pmod m,使用 exgcd 即可。

    时间复杂度 O(log⁡V)\mathcal{O}(\log V)。

    0x34 单个逆元的求解.cpp:

    // 单个逆元的求解
    i64 inverse(i64 a, i64 m) {
        auto [d, x, y] = exgcd(a, m);
        // assert(d == 1);
        return (x % m + m) % m;
    }

    多个逆元的求解

    若要求解多个整数 a1,…,ana_1, \dots, a_n 在模 mm 意义下的逆元,处理出前缀积与前缀积逆元,通过 ai−1=Si−1Si−1 mod ma^{-1}_i = S_{i - 1}S^{-1}_i \bmod m 求出所有数的逆元即可。

    时间复杂度 O(n)\mathcal{O}(n)。

    预处理线性逆元

    若要求解 1∼n1 \sim n 所有整数模质数 pp 意义下的逆元,对于 1<i<p1 < i < p,有

    0≡⌊pi⌋i+(p mod i)(modp)0 \equiv \left\lfloor \frac{p}{i} \right\rfloor i + (p \bmod i) \pmod p

    将等式两边同乘以 i−1(p mod i)−1i^{-1}(p \bmod i)^{-1},得

    i−1≡−⌊pi⌋(p mod i)−1(modp)i^{-1} \equiv -\left\lfloor \frac{p}{i} \right\rfloor (p \bmod i)^{-1} \pmod p

    根据上式递推即可。

    时间复杂度 O(n)\mathcal{O}(n)。

    0x34 预处理线性逆元.cpp:

    // 预处理线性逆元
    std::vector<int> v;
    void linearInverse(int n) {
        v.resize(n + 1);
        v[1] = 1;
        for (int i = 2; i <= n; i ++) {
            v[i] = 1ll * v[mod % i] * (mod - mod / i) % mod;
        }
    }

    线性同余方程

    裴蜀定理:设 a,ba, b 是不均为 00 的整数。

    • 存在整数 x,yx, y,使得 ax+by=gcd⁡(a,b)ax + by = \gcd(a, b)。
    • 对于任意整数 x,yx, y,均有 gcd⁡(a,b)∣ax+by\gcd(a, b) \mid ax + by。

    裴蜀定理可以扩展到更多维:设 a1,…,ana_1, \dots, a_n 是不均为 00 的整数。

    • 存在整数 x1,…,xnx_1, \dots, x_n,使得 ∑i=1naixi=gcd⁡(a1,…,an)\sum_{i = 1}^n a_ix_i = \gcd(a_1, \dots, a_n)。
    • 对于任意整数 x1,…,xnx_1, \dots, x_n,均有 gcd⁡(a1,…,an)∣∑i=1naixi\gcd(a_1, \dots, a_n) \mid \sum_{i = 1}^n a_ix_i。

    可以使用 gcd 的结合律进行归纳证明。

    exgcd(扩展欧几里得算法):用于求出二元一次不定方程 ax+by=gcd⁡(a,b)ax + by = \gcd(a, b) 的一组可行解 x,yx, y。

    在欧几里得算法的基础上归纳求解:

    • 当 b=0b = 0 时,有 x=1,y=0x = 1, y = 0,使得 a⋅1+0⋅0=gcd⁡(a,0)a \cdot 1 + 0 \cdot 0 = \gcd(a, 0)。
    • 当 b>0b > 0 时,由于 gcd⁡(a,b)=gcd⁡(b,a mod b)\gcd(a, b) = \gcd(b, a \bmod b),假设存在一对 x,yx, y 使得
      bx+(a mod b)y=gcd⁡(b,a mod b)bx + (a \bmod b)y = \gcd(b, a \bmod b)

    利用 a mod b=a−⌊ab⌋ba \bmod b = a - \left\lfloor \frac{a}{b} \right\rfloor b,并移项得

    ay+b(x−⌊ab⌋y)=gcd⁡(a,b)ay + b\left(x - \left\lfloor \frac{a}{b} \right\rfloor y\right) = \gcd(a, b)

    此时取 x′=y,y′=x−⌊ab⌋yx' = y, y' = x - \left\lfloor \frac{a}{b} \right\rfloor y,使得 ax′+by′=gcd⁡(a,b)ax' + by' = \gcd(a, b)。

    时间复杂度 O(log⁡max⁡(a,b))\mathcal{O}(\log \max(a, b))。

    可以证明,扩展欧几里得算法求出的可行解 x,yx, y 满足 ∣x∣≤b,∣y∣≤a|x| \leq b, |y| \leq a。

    0x34 exgcd(扩展欧几里得算法).cpp:

    // 扩展欧几里得算法
    std::array<i64, 3> exgcd(i64 a, i64 b) {
        if (b == 0) return {a, 1, 0};
        auto [d, x, y] = exgcd(b, a % b);
        return {d, y, x - (a / b) * y};
    }

    二元一次不定方程 ax+by=cax + by = c:

    • 有解性:当且仅当 gcd⁡(a,b)∣c\gcd(a, b) \mid c。
    • 通解:使用 exgcd 找出方程 ax+by=gcd⁡(a,b)ax + by = \gcd(a, b) 的一组特解 x0,y0x_0, y_0,则有通解
      x=cgcd⁡(a,b)x0+kbgcd⁡(a,b)y=cgcd⁡(a,b)y0−kagcd⁡(a,b)\begin{gathered} x = \frac{c}{\gcd(a, b)}x_0 + k\frac{b}{\gcd(a, b)} \\ y = \frac{c}{\gcd(a, b)}y_0 - k\frac{a}{\gcd(a, b)} \end{gathered}

    线性同余方程 ax≡b(modm)ax \equiv b \pmod m:

    该方程等价于 ax−bax - b 为 mm 的倍数,不妨设为 −y-y 倍,则原方程转化为 ax+my=bax + my = b。

    • 有解性:当且仅当 gcd⁡(a,m)∣b\gcd(a, m) \mid b。
    • 通解:使用 exgcd 找出方程 ax+my=gcd⁡(a,m)ax + my = \gcd(a, m) 的一组特解 x0,y0x_0, y_0,则有通解
      x=bgcd⁡(a,m)x0+kmgcd⁡(a,m)x = \frac{b}{\gcd(a, m)}x_0 + k\frac{m}{\gcd(a, m)}

    将线性同余方程中 xx 的系数消成 11:

    对于线性同余方程 ax≡b(modm)ax \equiv b \pmod m,有解的充要条件是 gcd⁡(a,m)∣b\gcd(a, m) \mid b。当满足该条件时,方程可以转化为

    agcd⁡(a,m)x≡bgcd⁡(a,m)(modmgcd⁡(a,m))\frac{a}{\gcd(a, m)}x \equiv \frac{b}{\gcd(a, m)} \pmod{\frac{m}{\gcd(a, m)}}

    此时 gcd⁡(agcd⁡(a,m),mgcd⁡(a,m))=1\gcd\left( \frac{a}{\gcd(a, m)}, \frac{m}{\gcd(a, m)} \right) = 1,xx 在模 mgcd⁡(a,m)\frac{m}{\gcd(a, m)} 意义下有唯一解 x′x'。

    于是线性同余方程 ax≡b(modm)ax \equiv b \pmod m 转化为了 x≡x′(modm′)x \equiv x' \pmod{m'} 的形式。该形式对线性同余方程组的求解大有用处。

    线性同余方程组

    模数两两互质的一元线性同余方程组(中国剩余定理,CRT):

    {x≡a1(modm1)x≡a2(modm2)…x≡an(modmn)\begin{cases} x \equiv a_1 \pmod{m_1} \\ x \equiv a_2 \pmod{m_2} \\ \dots \\ x \equiv a_n \pmod{m_n} \end{cases}
    • 记所有模数的积为 M=∏i=1nmiM = \prod_{i = 1}^n m_i。

    • 对于第 ii 个方程:

      • 记 Mi=MmiM_i = \frac{M}{m_i}。
      • 记 ViV_i 表示 MiM_i 在模 mim_i 意义下的逆元。
    • 特解:

      x0=∑i=1naiMiVix_0 = \sum_{i = 1}^n a_iM_iV_i
    • 通解:

      x=x0+kMx = x_0 + kM

    0x34 CRT(中国剩余定理).cpp:

    i64 inverse(i64 a, i64 m) {
        auto [d, x, y] = exgcd(a, m);
        return (x % m + m) % m;
    }
    
    using equ = std::pair<i64, i64>; // {a, m} 表示方程 x = a (mod m)
    
    // 中国剩余定理
    equ CRT(std::vector<equ> seq) {
        i64 M = 1;
        for (auto [a, m] : seq) {
            M *= m;
        }
        i64 x = 0;
        for (auto [a, m] : seq) {
            i64 Mi = M / m;
            i64 Vi = inverse(Mi, m);
            x = (x + a * Mi * Vi) % M; // 必要时,使用“快速乘”防止爆 long long
        }
        x = (x % M + M) % M;
        return {x, M};
    }

    不保证模数两两互质的一元线性同余方程组(扩展中国剩余定理,exCRT):

    仅考虑两个方程的合并(多个方程的情况,可以依次合并)。设这两个方程为

    {x≡a1(modm1)x≡a2(modm2)\begin{cases} x \equiv a_1 \pmod{m_1} \\ x \equiv a_2 \pmod{m_2} \end{cases}

    则

    x=pm1+a1=qm2+a2⟹m1p−m2q=a2−a1x = pm_1 + a_1 = qm_2 + a_2 \Longrightarrow m_1p - m_2q = a_2 - a_1

    使用 exgcd 找出方程 m1p−m2q=a2−a1m_1p - m_2q = a_2 - a_1 的一组特解 p0,q0p_0, q_0,或判断无解。

    此时取 a′=p0m1+a1a' = p_0m_1 + a_1 与 m′=lcm⁡(m1,m2)m' = \operatorname{lcm}(m_1, m_2),两个方程合并为

    x≡a′(modm′)x \equiv a' \pmod{m'}

    0x34 exCRT(扩展中国剩余定理).cpp:

    // 扩展中国剩余定理
    struct equ {
        i64 a, m; // {a, m} 表示方程 x = a (mod m)
        equ() {}
        equ(i64 a, i64 m) : a(a), m(m) {}
    
        friend equ operator + (equ l, equ r) {
            auto [a1, m1] = l;
            auto [a2, m2] = r;
            if (a1 == -1 || a2 == -1) {
                return {-1, -1};
            }
            auto [d, x, y] = exgcd(m1, m2);
            if ((a2 - a1) % d) {
                return {-1, -1};
            }
            x = x * ((a2 - a1) / d) % (m2 / d); // 必要时,使用“快速乘”防止爆 long long
            if (x < 0) x += (m2 / d);
            i64 m = m1 * (m2 / d);
            i64 a = (x * m1 + a1) % m; // 必要时,使用“快速乘”防止爆 long long
            return {a, m};
        }
    };

    阶与原根

    阶:设整数 m>0m > 0,满足 ax≡1(modm)a^x \equiv 1 \pmod m 的最小正整数 xx,称作 aa 模 mm 的阶。记作 ordm(a)\mathrm{ord}_m(a)。

    阶的存在条件:当且仅当 gcd⁡(a,m)=1\gcd(a, m) = 1 时,aa 模 mm 的阶存在。

    必要性:当 gcd⁡(a,m)≠1\gcd(a, m) \neq 1 时,aa 在模 mm 意义下的逆元不存在。故必定有 gcd⁡(a,m)=1\gcd(a, m) = 1。

    充分性:当 gcd⁡(a,m)=1\gcd(a, m) = 1 时,由欧拉定理 aφ(m)≡1(modm)a^{\varphi(m)} \equiv 1 \pmod m,故此时阶必定存在,并且 ordm(a)∣φ(m)\mathrm{ord}_m(a) \mid \varphi(m)。

    阶的简单性质:

    • 若 a⊥ma\perp m,则 a,a2,…,aordm(a)a, a^2, \dots, a^{\mathrm{ord}_m(a)} 模 mm 两两不同。
    • 若 a⊥ma \perp m,则 ordm(a)∣φ(m)\mathrm{ord}_m(a) \mid \varphi(m)。
    • 若 a⊥ma \perp m,则
      ordm(ak)=ordm(a)gcd⁡(ordm(a),k)\mathrm{ord}_m(a^k) = \frac{\mathrm{ord}_m(a)}{\gcd(\mathrm{ord}_m(a), k)}

    简单推导:ordm(ak)=lcm(ordm(a),k)k\mathrm{ord}_m(a^k) = \frac{\mathrm{lcm}(\mathrm{ord}_m(a), k)}{k}。

    • 若 a⊥m,b⊥ma\perp m, b\perp m,则

      lcm(ordm(a),ordm(b))gcd⁡(ordm(a),ordm(b))∣ordm(ab)∣lcm(ordm(a),ordm(b))\frac{\mathrm{lcm}(\mathrm{ord}_m(a), \mathrm{ord}_m(b))}{\gcd(\mathrm{ord}_m(a), \mathrm{ord}_m(b))} \mid \mathrm{ord}_m(ab) \mid \mathrm{lcm}(\mathrm{ord}_m(a), \mathrm{ord}_m(b))
    • 若 a⊥m,b⊥ma \perp m, b \perp m,则

      ordm(ab)=ordm(a)ordm(b)  ⟺  gcd⁡(ordm(a),ordm(b))=1\mathrm{ord}_m(ab) = \mathrm{ord}_m(a)\mathrm{ord}_m(b) \iff \gcd(\mathrm{ord}_m(a), \mathrm{ord}_m(b)) = 1
    • 若 a⊥m,b⊥ma \perp m, b\perp m,则总是存在满足 c⊥mc\perp m 的 cc,使得

      ordm(c)=lcm(ordm(a),ordm(b))\mathrm{ord}_m(c) = \mathrm{lcm}(\mathrm{ord}_m(a), \mathrm{ord}_m(b))

    简单构造:将 ordm(a),ordm(b)\mathrm{ord}_m(a), \mathrm{ord}_m(b) 唯一分解

    ordm(a)=∏pisi,ordm(b)=∏piti\mathrm{ord}_m(a) = \prod p_i^{s_i}, \quad \mathrm{ord}_m(b) = \prod p_i^{t_i}

    根据 sis_i 与 tit_i 的大小关系,可以将所有质因子分成两类

    A={i∣si≥ti},B={i∣si<ti}A = \{ i \mid s_i \geq t_i \}, \quad B = \{ i \mid s_i < t_i \}

    记

    xA=∏i∈Apisi,xB=∏i∈Bpisi,yA=∏i∈Apiti,yB=∏i∈Bpitix_A = \prod_{i \in A} p_i^{s_i}, \quad x_B = \prod_{i \in B} p_i^{s_i}, \quad y_A = \prod_{i \in A} p_i^{t_i}, \quad y_B = \prod_{i \in B} p_i^{t_i}

    此时 ordm(a)=xAxB,ordm(b)=yAyB\mathrm{ord}_m(a) = x_Ax_B, \mathrm{ord}_m(b) = y_Ay_B,可得

    ordm(axB)=xA,ordm(byA)=yB\mathrm{ord}_m(a^{x_B}) = x_A, \quad \mathrm{ord}_m(b^{y_A}) = y_B

    又由于 xA⊥yBx_A \perp y_B,所以

    ordm(axBbyA)=xAyB=∏pimax⁡(si,ti)=lcm(ordm(a),ordm(b))\mathrm{ord}_m(a^{x_B}b^{y_A}) = x_Ay_B = \prod p_i^{\max(s_i, t_i)} = \mathrm{lcm}(\mathrm{ord}_m(a), \mathrm{ord}_m(b))

    取 c=axBbyAc = a^{x_B}b^{y_A} 即可。

    原根:设整数 m>0m > 0,若 gcd⁡(g,m)=1\gcd(g, m) = 1 且 ordm(g)=φ(m)\mathrm{ord}_m(g) = \varphi(m),则称 gg 为模 mm 的原根。

    此时 g,g2,…,gφ(m)g, g^2, \dots, g^{\varphi(m)} 构成了 mm 的简化剩余系。

    原根判定定理:设整数 m≥3m \geq 3,则 gg 是模 mm 的原根,当且仅当 gcd⁡(g,m)=1\gcd(g, m) = 1 且对于 φ(m)\varphi(m) 的每个质因子 pp,都有

    gφ(m)p≢1(modm)g^{\frac{\varphi(m)}{p}} \not\equiv 1 \pmod m

    原根存在定理:mm 存在原根,当且仅当 m=1,2,4,pc,2pcm = 1, 2, 4, p^c, 2p^c(其中 pp 为奇质数且 c≥1c \geq 1)。

    阶的数量:若 mm 存在原根,则对于 d∣φ(m)d \mid \varphi(m),阶等于 dd 的元素恰好有 φ(d)\varphi(d) 个。

    简单推导:设 mm 的原根为 gg,则 mm 的简化剩余系中的元素可以写成 gk mod mg^k \bmod m 的形式,其中 1≤k≤φ(m)1 \leq k \leq \varphi(m)。则

    ordm(gk)=φ(m)gcd⁡(φ(m),k)\mathrm{ord}_m(g^k) = \frac{\varphi(m)}{\gcd(\varphi(m), k)}

    令 ordm(gk)=d\mathrm{ord}_m(g^k) = d,则有 gcd⁡(φ(m),k)=φ(m)d\gcd(\varphi(m), k) = \frac{\varphi(m)}{d}。

    整个式子除以 φ(m)d\frac{\varphi(m)}{d} 可得 gcd⁡(d,k′)=1\gcd(d, k') = 1,其中 1≤k′≤d1 \leq k' \leq d,此时 k′k' 的数量为 φ(d)\varphi(d)。

    原根数量:若 mm 存在原根,则 mm 的原根个数为 φ(φ(m))\varphi(\varphi(m))。

    相当于是阶等于 φ(m)\varphi(m) 的元素个数,由上述分析,恰好有 φ(φ(m))\varphi(\varphi(m)) 个。

    最小原根的上界:若 mm 存在原根,则 mm 的最小原根的上界为 m0.25m^{0.25} 级别。

    原根求解:若 mm 存在原根,先求出 φ(m)\varphi(m),再求出 φ(m)\varphi(m) 的唯一分解形式。此时就可以根据“原根判定定理”配合快速幂判断一个数是否为 mm 的原根。

    从小到大暴力寻找原根,即可找到最小原根 gg。

    当我们已知其中一个原根 gg 时,可以根据 gg 生成其他所有的原根。对于所有满足 1≤k≤φ(m)1 \leq k \leq \varphi(m) 且 gcd⁡(k,φ(m))=1\gcd(k, \varphi(m)) = 1 的 kk,这些 gk mod mg^k \bmod m 不重不漏地覆盖了所有原根。

    0x34 最小原根.cpp:

    // 最小原根
    int findPrimitiveRoot(int m) {
        if (m == 1) return 0;
        if (m == 2) return 1;
    
        int phi = m, x = m; // 若已知 m 为质数,则直接令 phi = m - 1
        for (int i = 2; i * i <= x; i ++) {
            if (x % i == 0) {
                phi = phi / i * (i - 1);
                while (x % i == 0) {
                    x /= i;
                }
            }
        }
        if (x > 1) {
            phi = phi / x * (x - 1);
        }
    
        std::vector<int> pf;
        x = phi;
        for (int i = 2; i * i <= x; i ++) {
            if (x % i == 0) {
                pf.push_back(i);
                while (x % i == 0) {
                    x /= i;
                }
            }
        }
        if (x > 1) {
            pf.push_back(x);
        }
    
        for (int g = 2; g < m; g ++) {
            if (std::gcd(g, m) != 1) { // 若已知 m 为质数,则可以省略该判断
                continue;
            }
            int flag = 1;
            for (int p : pf) {
                if (qpow(g, phi / p, m) == 1) {
                    flag = 0;
                    break;
                }
            }
            if (flag) {
                return g;
            }
        }
        return -1; // 若 m 较大,建议先判断 m 是否存在原根
    }

    0x34 所有原根.cpp:

    // 所有原根
    std::vector<int> allPrimitiveRoot(int m) {
        if (m == 1) return {0};
        if (m == 2) return {1};
    
        int phi = m, x = m; // 若已知 m 为质数,则直接令 phi = m - 1
        for (int i = 2; i * i <= x; i ++) {
            if (x % i == 0) {
                phi = phi / i * (i - 1);
                while (x % i == 0) {
                    x /= i;
                }
            }
        }
        if (x > 1) {
            phi = phi / x * (x - 1);
        }
    
        std::vector<int> pf;
        x = phi;
        for (int i = 2; i * i <= x; i ++) {
            if (x % i == 0) {
                pf.push_back(i);
                while (x % i == 0) {
                    x /= i;
                }
            }
        }
        if (x > 1) {
            pf.push_back(x);
        }
    
        int g = 2;
        for (; g < m; g ++) {
            if (std::gcd(g, m) != 1) { // 若已知 m 为质数,则可以省略该判断
                continue;
            }
            int flag = 1;
            for (int p : pf) {
                if (qpow(g, phi / p, m) == 1) {
                    flag = 0;
                    break;
                }
            }
            if (flag) {
                break;
            }
        }
        if (g == m) {
            return {};
        }
    
        std::vector<int> res;
        x = 1;
        for (int i = 1; i <= phi; i ++) {
            x = 1ll * x * g % m;
            if (std::gcd(i, phi) == 1) {
                res.push_back(x);
            }
        }
        std::sort(res.begin(), res.end());
        return res;
    }

    离散对数

    离散对数:设整数 m>0m > 0 存在原根 gg,对于 mm 的简化剩余系中的元素 aa,必存在唯一的整数 0≤k<φ(m)0 \leq k < \varphi(m) 使得 gk≡a(modm)g^k \equiv a \pmod m。

    此时称 kk 为以 gg 为底,模 mm 的离散对数。记作 k=indg(a)k = \mathrm{ind}_g(a)。

    离散对数的简单性质:

    • indg(ab)≡indg(a)+indg(b)(modφ(m))\mathrm{ind}_g(ab) \equiv \mathrm{ind}_g(a) + \mathrm{ind}_g(b) \pmod{\varphi(m)}。
      说明离散对数可以将“模 mm 意义下乘法”转换成“模 φ(m)\varphi(m) 意义下加法”。
    • indg(ak)≡kind⁡g(a)(modφ(m))\mathrm{ind}_g(a^k) \equiv k\operatorname{ind}_g(a) \pmod{\varphi(m)}。
    • indg1(a)≡ind⁡g2(a)ind⁡g1(g2)(modφ(m))\mathrm{ind}_{g_1}(a) \equiv \operatorname{ind}_{g_2}(a) \operatorname{ind}_{g_1}(g_2) \pmod{\varphi(m)}。其中 g1,g2g_1, g_2 均为 mm 的原根。

    高次同余方程

    固定底数且与模数互质的高次同余方程 ax≡b(modp)a^x \equiv b \pmod{p}(BSGS):

    取 S=⌈p⌉S = \left\lceil \sqrt{p} \right\rceil,设 x=iS−jx = iS - j(其中 i≥1i \geq 1 且 0≤j<S0 \leq j < S),则有

    aiS−j≡b(modp)aiS×a−j≡b(modp)aiS≡b×aj(modp)\begin{gathered} a^{iS - j} \equiv b \pmod p \\ a^{iS} \times a^{-j} \equiv b \pmod p \\ a^{iS} \equiv b \times a^j \pmod p \end{gathered}

    预处理 0≤j<S0 \leq j < S 的 b×aj mod pb\times a^j \bmod p 存入哈希表,枚举所有 1≤i≤S1 \leq i \leq S,在哈希表中查询 (aS)i mod p(a^S)^i \bmod p 及其对应的 jj。如果查询成功则返回 iS−jiS - j。如果一直查询失败则方程无解。

    时间复杂度 O(p)\mathcal{O}(\sqrt{p})。

    0x34 BSGS(大步小步算法).cpp:

    // 大步小步算法
    int BSGS(int a, int b, int p) { // a^x = b (mod p)
        if (b == 1 || p == 1) return 0;
        if (a == 0) return b == 0 ? 1 : -1;
    
        int S = sqrt(p) + 1;
        std::unordered_map<int, int> buc;
    
        int w = 1;
        for (int j = 0; j < S; j ++, w = 1ll * w * a % p) {
            int v = 1ll * w * b % p;
            buc[v] = j;
        }
        int x = w;
        for (int i = 1; i <= S; i ++, x = 1ll * x * w % p) {
            if (buc.contains(x)) {
                return i * S - buc[x];
            }
        }
        return -1;
    }

    固定底数且不保证与模数互质的高次同余方程 ax≡b(modp)a^x \equiv b \pmod{p}(exBSGS):

    该方程等价于 ax−ba^x - b 为 pp 的倍数,不妨设为 −k-k 倍,则原方程转化为 a⋅ax−1+kp=ba\cdot a^{x - 1} + kp = b。

    若 gcd⁡(a,p)∤b\gcd(a, p) \nmid b 则无解,否则

    ax−1agcd⁡(a,p)+kpgcd⁡(a,p)=bgcd⁡(a,p)a^{x - 1} \frac{a}{\gcd(a, p)} + k\frac{p}{\gcd(a, p)} = \frac{b}{\gcd(a, p)}

    每次将 agcd⁡(a,p)\frac{a}{\gcd(a, p)} 提取出来,并将 b,pb, p 除以 gcd⁡(a,p)\gcd(a, p),就变成了一个规模更小的子问题。

    记已经提取出的系数之积为 r=∏agcd⁡(a,p)r = \prod \frac{a}{\gcd(a, p)}。在递降的过程中,若 r≡b′(modp′)r \equiv b' \pmod{p'},则直接返回答案。

    否则一直递降直到 gcd⁡(a,p′)=1\gcd(a, p') = 1,此时得到一个固定底数且与模数互质的高次同余方程 rax≡b′(modp′)ra^x \equiv b' \pmod{p'},套用 BSGS。

    0x34 exBSGS(扩展大步小步算法).cpp:

    // 扩展大步小步算法
    int exBSGS(int a, int b, int p) { // a^x = b (mod p)
        if (b == 1 || p == 1) return 0;
        if (a == 0) return b == 0 ? 1 : -1;
    
        int d, r = 1, step = 0;
        while (d = std::gcd(a, p), d > 1) {
            if (b % d) {
                return -1;
            }
            b /= d, p /= d, r = 1ll * r * (a / d) % p;
            step ++;
            if (r == b) {
                return step;
            }
        }
        if (p == 1) {
            return step;
        }
    
        int S = sqrt(p) + 1;
        std::unordered_map<int, int> buc;
    
        int w = 1;
        for (int j = 0; j < S; j ++, w = 1ll * w * a % p) {
            int v = 1ll * w * b % p;
            buc[v] = j;
        }
        int x = 1ll * r * w % p;
        for (int i = 1; i <= S; i ++, x = 1ll * x * w % p) {
            if (buc.contains(x)) {
                return step + i * S - buc[x];
            }
        }
        return -1;
    }

    固定次数且模数为质数的高次同余方程 xa≡b(modp)x^a \equiv b \pmod p:设 pp 的原根为 gg,记 x=gcx = g^c(这里 cc 是未知数),问题转化为

    (ga)c≡b(modp)(g^a)^c \equiv b \pmod p

    记 v=gav = g^a,此时得到一个固定底数的高次同余方程 vc≡b(modp)v^c \equiv b \pmod p。

    • 特解:x≡gc(modp)x \equiv g^{c} \pmod p,使用 BSGS 得到。
    • 通解:x≡gc+kp−1gcd⁡(p−1,a)(modp)x \equiv g^{c + k\frac{p - 1}{\gcd(p - 1, a)}} \pmod{p},此时 k=0,1,…,gcd⁡(p−1,a)−1k = 0, 1, \dots, \gcd(p - 1, a) - 1,其中 p−1gcd⁡(p−1,a)\frac{p - 1}{\gcd(p - 1, a)} 表示 ordp(ga)\mathrm{ord}_p(g^a)。

    注意特判 b=0b = 0 的情况。

    Misc

    平方差

    平方差表示:只有 1,2,41, 2, 4,以及所有形如 4k+24k + 2 的正整数,不能被表示成两个不同正整数的平方差。

    平方差表示证明:对于正整数 nn,相当于判断是否存在两个不同的正整数 a,ba, b (a>ba > b) 使得 n=a2−b2=(a+b)(a−b)n = a^2 - b^2 = (a + b)(a - b)。

    设 x=a+b,y=a−bx = a + b, y = a - b,则 n=xyn = xy。由于 x,yx, y 之间的差为 2b2b,所以 x,yx, y 奇偶性相同。对于同奇偶的两个 x,yx, y (x>yx > y),也都可以解出 a,ba, b 的值。

    故对于正整数 nn,相当于是要找出 nn 的两个不同的约数 x,yx, y,且 x,yx, y 奇偶性相同。

    • 当 nn 为奇数时,取 x=n,y=1x = n, y = 1 即可。
    • 当 nn 为偶数时:
      • 当 n=4kn = 4k 时,取 x=2k,y=2x = 2k, y = 2 即可。
      • 当 n=4k+2n = 4k + 2 时,分解出的两个约数,必为一奇一偶。
    • n=1,2,4n = 1, 2, 4 为特殊情况,均不能被表示。

    0x35 数学 离散数学

    0x36 数学 线性代数

    0x37 数学 概率论

    0x38 数学 博弈论