Runtime Error

地狱人

Unknown — Thu, 23 Apr 2026 00:00:00 +0000

求解 $g^x\equiv a\pmod P$，即 $\operatorname{ind}_ga\equiv x\pmod{(P-1)}$。要求 $P-1$ 较 smooth。

考虑对模数动手。首先我们要明确离散对数在其他模数下的定义。假设模数 $m\mid(P-1)$，$\operatorname{ind}_ga\equiv x_0\pmod m$。带入原始的指数方程：

$$ g^{km+x_0}\equiv a\pmod P $$

为分离出 $x_0$，我们要消灭掉指数上的 $m$。由 Fermat 小定理，有 $g^{P-1}\equiv 1\pmod P$，且我们有 $m\mid(P-1)$，故可以左右同取 $\frac{P-1}{m}$ 次幂：

$$ \left(g^{km+x_0}\right)^{\frac{P-1}{m}}\equiv g^{k(P-1)}\cdot g^{\frac{(P-1)x_0}m}\equiv \left(g^{\frac{P-1}{m}}\right)^{x_0}\equiv a^{\frac{P-1}m}\pmod P $$

如果令 $G=g^{\frac{P-1}m},A=a^{\frac{P-1}m}$，那么我们就得到 $G^{x_0}\equiv A\pmod P$ 的形式。

这个过程在对数意义下也很直观，因为我们可以将整个同余式乘上 $\frac{P-1}{m}$：

$$ \frac{(P-1)x_0}{m}\equiv \frac{P-1}m\operatorname{ind}_ga\equiv \operatorname{ind}_g a^{\frac{P-1}m}\pmod{(P-1)} $$

Pohlig-Hellman 算法基于以下观察：若已知 $x$ 满足 $\operatorname{ind}_g a\equiv x\pmod {p}$，那么我们容易求解 $\operatorname{ind}_ga\equiv x'\pmod {pq}$。设 $x'=kp+x(0\le k<q)$，还原成指数形式有：

$$ a^{\frac{P-1}{pq}}\equiv \left(g^{kp+x}\right)^{\frac{P-1}{pq}}\equiv\left(g^{\frac{P-1}{q}}\right)^k\cdot g^{\frac{(P-1)x}{pq}}\pmod P $$

由这个式子，我们可以用 BSGS 解出 $k$，进而得出 $x'$。单次递推的复杂度为 $O(\sqrt q)$。

利用这个结论，比较自然的想法是：选取一个模数路径 $m_1\mid m_2\mid \dots\mid m_n=P-1$，求出 $\operatorname{ind}_g a\equiv x_1\pmod {m_1}$，然后依次递推出答案。这当然是可行的，不过稍显复杂。

我们知道求解各种模意义下的方程，经常用到 CRT。在这个算法下，CRT 其实也可以看作是模数 $p\to pq$ 的一次递推，即先求解模 $p$ 和 $q$ 的 case，然后合并。在底数固定的情况下，CRT 合并的开销极低，那么我们大可以将所有 $p,q$ 互质的情况都用 CRT。于是我们只需要考虑用刚才的递推求解 $\operatorname{ind}_ga\equiv x\pmod {p^\alpha}$。

为了减小递推的开销，Pohlig-Hellman 算法直接令模数路径中相邻项之间的商为素因子 $p$，即令模数按照 $p\to p^2\to\dots$ 的路径递推。那么以上的 P-H 递推可以形象地解释为 $p$ 进制数位的递推：设 $x$ 的 $p$ 进制表示为 $x=x_0+x_1p+\dots+x_{\alpha-1}p^{\alpha - 1}$。这个对数方程左右同乘上一个 $p^j$，就抹去了 $x$ 在 $p$ 进制下的较高位：

$$ p^j\operatorname{ind}_ga\equiv \sum_{i<\alpha}x_ip^{i+j}\pmod {p^\alpha} $$

于是等式右边 $i+j\ge\alpha$ 的项就全部被抹去，得到一个关于 $x_0,x_1,\dots,x_{\alpha-j-1}$ 的等式。为了能够计算，化为指数形式：

$$ A^{p^j}\equiv G^{\sum_{i+j<\alpha}x_ip^{i+j}}\equiv \prod_{i+j<\alpha}G^{x_ip^{i+j}}\pmod P $$

此时我们可以用 BSGS 算出 $x_{\alpha-j-1}$。实际实现中，由于 $p$ 较小，有时也会直接枚举 $x_{\alpha-j-1}$ 并验证来求解，以避免 BSGS 较大的常数。解决模 $p^\alpha$ 的单个 case 的复杂度为 $O(\sqrt p\alpha)$，总复杂度为 $O(\sum (\sqrt{p_i}\alpha_i+\log P))\approx O((\sqrt{\max p}+\omega(P-1))\log P)$。

回顾 BSGS，我们是对指数做了一个根号分块。那么在 P-H 中，我们通过变换模数，将指数分为了 $\alpha=O(\log P)$ 块求解，并保证这个分块有易于求解的性质。

更进一步地，模数路径中相邻项之商可以灵活选取。对较大的 $\alpha$，可以令模数按照 $p^{\beta}\to p^{2\beta}\to\dots$ 的路径递推，即将指数看作 $p^\beta$ 进制数。算法过程与之前类似，此时单个 case 的复杂度为 $O(p^{\beta/2}\cdot\frac\alpha\beta)$。

接下来考虑多次询问的情况下，如何预处理以优化单次询问。

注意到方程中含 $x_{\alpha-j-1}$ 的一项中，指数内 $p$ 的幂次必定被提升至了 $\alpha-1$，故在预处理时，可以打这样一个表：算出 $\forall x\in[0,p)$ 的 $G^{xp^{\alpha-1}}$，并构建一个逆映射。这样求解时直接查询即可。
设在模 $p_i^{\alpha_i}$ 的 case 下将指数看作 $p_i^{\beta_i}$ 进制数，那么该 case 的预处理需要 $O(p_i^{\beta_i})$ 时间/空间，查询复杂度则为 $O(\alpha_i/\beta_i+\log P)$。
P-H 查询时的复杂度瓶颈之一在于，对 CRT 分离出的每个 $p^\alpha$ case，我们都要算一遍 $A=a^{\frac{P-1}{p^\alpha}}$ 及所有 $A^{p^j}$，这有时过于昂贵。对较小的 $p^\alpha$，我们可以设定阈值 $S$，贪心地将若干个 $p^\alpha$ 分成一组（只要它们的积不超过 $S$），并暴力 BSGS 或全部预处理。这样我们就减少了 $A$ 部分的快速幂次数。如对 $P=998244353=2^{23}\times7\times17+1$，可以将 $7\times17$ 打包成一组。

事实上后两条优化都脱胎于模数路径的选取。原则很简单：合并互质模数时，CRT 优于 P-H 递推；视具体情况，平衡预处理和递推开销。

To see the next part of the dream

Unknown — Thu, 01 Jan 2026 00:00:00 +0000

Mutilated Memory

我常避免在文字中谈及自己的回忆。那些碎片的、光影般的记忆似乎不值一提，我也无法找到合适的词句把它们连缀成篇。

可是，那些记忆都去哪了？回想起来，我似乎常常抨击高中，有关那些条条框框的一切，以及被浪费的时间：就像记忆被切走一般。套用我高三时钟爱的拉美文学手法，那些记忆想必只在我经历它们时存在，在那些瞬间经过后，它的意义、存在都即刻灰飞烟灭。

在高考过后许久的，同一年冬季里，会有友人与我闲聊时，用抨击高中生活时同样的话术，再度抨击大一的在校时光。在某些比较 emo 的时刻，也许他又会质疑起一些无谓的问题：“生命的意义是什么？”我会在无数次的敷衍过后，思忖许久，说出：“那是你唯一的自由”。

或许我的眼界只允许我对存在主义有如此的理解：我们把仅剩的一切看作自由，生活高贵的恩赐。那么，且就贪婪地把“意义”归于这自由中吧——可那高中剩下的一切，我所痛苦地回忆，咒骂的无意义的时光，却显得矛盾了。

我会在无数个陷入幽微的时刻这样剖析我自己：也许我所憎恶的一切，都是我自己惰性的某种伪装。我也会剖析我对自我的剖析：也许我擅长剖析自我，却不擅长改变自我——归根到底，我擅长讨厌自我。但这又是在跌入幽微的深渊时我才会去想的事情了。多数时刻，我只是伪饰着我的懒惰，以某种刻意的淡然和“摆烂”姿态生活着。

“就这样无知地生活下去多么美好”，每当自认为窥破了什么真相，人们都会这么想，这听上去十分讽刺。可对自我的剖析似乎的确是这样的。在自我认知之外的缺陷似乎却算不上缺陷，你从未探索过这种可能，它的未来就永不会存在。你经历的选择越多，错过的岔路也就越多。

但纵使有再多可能性又如何呢。一切创作都要有终稿的。

Paradise Noise

曾经我无法理解听金属的人。我无法从混作一顿嘈杂的频率中找到快感或美感。这甚至与“噪声”不同（我挺喜欢 noise pop/rock），更像是一段乐音被压缩至极低的音质，再去辨认其中的音符。

至少，高三下学期我是那么想的。那时我几乎整日被锁在学校，即使我愿意也无法将自己扔进耳机间的世界中，一切的乐章都是在脑中重现的。也是在那时，晚上回家的时段我相当沉迷于读日轻。我尤其喜欢的作者是杉井光，他所描写的音乐有一种火焰一般感人的能力，阅读他的文字时，我常思考，这世上是否真能有此“至乐”存在；但我却从来难 get 到他所热衷于，并为其音乐写下如此精彩文字的 beatles, led zeppelin 等乐队。

那时的我自然无法理解，《乐园杂音》中真琴第一次走进录音室，所听见那种乐声时的心情。“从耳机中听音乐，对音乐的理解自然局限在耳机中”“耳机中的音乐，与现场所听见的音乐，是两种截然不同的世界”。

那的确是一种不同的世界——仅仅拨片轻撩过琴弦的试音过程，心脏都止不住颤动。没有什么能够比拟使你脑后的发梢都被震动的音浪。锈蚀的电吉他声，与耳鸣混合为底噪的 bass 轰鸣，和每一击如同攥住你的呼吸、地狱一步步迫近的鼓点。但这些还不够重要。我爱的是音乐的天国，冷漠的城市中，噪音所怀抱的故乡。融化的人群。和那仿佛集体磕了药一样，无人能幸免的，牵动所有人体一切动作的节奏。年末去听刺猬 live 时，我甚至怀疑听众里正常人太多，以致氛围不足（当然这怀疑在《24 小时摇滚派对》响起后便烟消云散）。

在听完夏末的第一场 live，回校的地铁上，我所想的大概与现在我回忆那些现场时相同：那些在心里一闪而过，描述现场所感的词句我已再无法捕捉。那晚回校后，我犹豫许久，最终还是没能落下一字。去重复那些我已想遍、写烂的主题简单却也无趣，可那新添的回忆却无处安放，无处寻找。

常常有乐句像这些词语一样，在梦中、或其他莫名其妙的时刻闪现在我脑中。可惜我辨音能力极差，即使手边就有记录工具，也无法凭借旋律的哼唱还原出那些想必绝妙的旋律。仿佛陷入创作欲漫溢至腐烂的困境。

每到某些时刻我会听着耳机中的旋律，相信音乐是信仰；某些时刻我觉得它们只是频率而已，和文字无差异，不过是一些曲线，数字的组合。意义的辩论似乎又在嘲讽着我了。

也许吧，当这些起伏不再困扰我时，我终于能学会创作。

26.1.1 凌晨 by Resory

PE 随机做题寄录

Unknown — Thu, 18 Dec 2025 00:00:00 +0000

不定期持续（不保证）更新。

PE169 Sums of Powers of Two

date: 12.17 ~~diff: 50~~ level: 16

题意：定义 $f(n)$ 为 $n$ 表示为若干个 $2$ 的幂之和的形式，且每个幂出现次数最多两次的方案数。

已知 $f(10)=5$。求 $f(10^{25})$。

AI 用递推秒了。这里叙述一种我自己的神秘做法。

考虑将 $n$ 的二进制表示从高次幂向低次幂“展开”。具体地说，将 $2^n$ 展开至 $k$ 次表示：

$$ 2^n=2^{n-1}+\dots+2\cdot2^k $$

发现这里的 $k$ 除了不能是原表示中已有的幂以外没有什么限制。于是我们可以安全地令这样的展开穿过某些中间的幂次 $2^m(k<m<n)$。注意展开到 $k$ 次之后所有高于 $k$ 次的幂都不能再展开了，于是可以递归求解。

复杂度 $O(\log n)$。

code

from functools import lru_cache
from math import log

def bits(N):
    l = [i for i in range(int(log(N) / log(2)) + 2) if N // (2**i) % 2 == 1]
    l.reverse()
    return l

def toN(l):
    return sum(2**i for i in l)

@lru_cache(maxsize=None)
def solve2(N):
    bit = bits(N)
    if len(bit) == 1:
        return bit[0] + 1
    res = bit[-1] + solve2(toN(bit[1:]))
    for ix in range(1, len(bit)):
        res += (bit[ix - 1] - bit[ix] - 1) * solve2(toN(bit[ix:]))
    return res

print(solve2(N))

PE216 The Primality of $2n^2-1$

date: 12.18 ~~diff: 45~~ level: 13

题意：令 $t(n)=2n^2-1$，求 $2\le n\le N$ 时有多少个 $n$ 使得 $t(n)$ 为素数。

已知 $N=10000$ 时有 $2202$ 个。求 $N=5\times10^7$ 时有多少。

~~这种傻逼题怎么能有 45 difficulty 的啊？~~ 为什么评论区还有一堆 Miller-Rabin 硬草过去的啊？

直接筛 $t(n)$ 这个多项式即可。$p\mid t(n)\iff n\equiv \pm1/2\pmod p$。

复杂度是常数比较小的 $O(N\log\log N)$。分块筛可以做到更小的时空复杂度。

code

没怎么优化，空间复杂度很大

#include <bitset>
#include <cmath>
#include <iostream>
#include <random>
#include <utility>
#include <vector>

using i64 = long long;
using pii = std::pair<i64, i64>;

const int N = 5e7;
const int L = 8e7;

std::vector<i64> primes, rt;
std::bitset<(L >> 1) + 1> isp;
std::bitset<N + 1> tn;

i64 fpow(i64 a, i64 b, i64 m) {
    i64 res = 1;
    for (a %= m; b; b >>= 1, a = a * a % m)
        if (b & 1) res = res * a % m;
    return res;
}

i64 sub(i64 a, i64 b, i64 m) { return ((a - b) % m + m) % m; }

pii mkp(i64 first, i64 second) { return std::make_pair(first, second); }

bool chk_rt(i64 a, i64 p) { return fpow(a, p >> 1, p) == 1; }

// Cipolla
i64 find_rt(i64 a, i64 p) {
    if (a == 0) return 0;
    if ((p & 3) == 3) return fpow(a, (p + 1) >> 2, p);

    static std::mt19937 rd(std::random_device{}());
    i64 r, y;
    do
        r = rd() % p;
    while (chk_rt(y = sub(r * r, a, p), p));

    auto mul = [&](const pii &a, const pii &b) {
        return mkp(
            (a.first * b.first + y * a.second % p * b.second) % p,
            (a.first * b.second + a.second * b.first) % p
        );
    };

    auto ppow = [&](const pii &a, i64 b) {
        pii res = mkp(1, 0), bs = a;
        for (; b; b >>= 1, bs = mul(bs, bs))
            if (b & 1) res = mul(res, bs);
        return res;
    };

    return ppow(mkp(r, 1), (p + 1) >> 1).first;
}

i64 t(i64 n) { return 2 * n * n - 1; }

int main() {
    auto append = [&](i64 p) {
        primes.push_back(p);
        rt.push_back(find_rt((p + 1) >> 1, p));
    };

    for (int i = 3; i <= L; i += 2) { // odd
        if (!isp[i >> 1]) {
            // primes i satisfying 1/2 is a quadratic residue
            if (chk_rt((i + 1) >> 1, i)) append(i);

            for (int j = 3 * i; j <= L; j += (i << 1))
                isp[j >> 1] = true;
        }
    }

    int pcnt = primes.size();
    for (int i = 0; i < pcnt; i++) {
        i64 p = primes[i], c = (rt[i] % p + p) % p;

        // p|t(n) iff n^2 equiv 1/2 mod p iff n equiv pm c mod p
        i64 s1 = c, s2 = p - c;
      
        for (i64 j = 0; j <= N; j += p) {
            if (s1 + j <= N && t(s1 + j) != p) tn[s1 + j] = true;
            if (s2 + j <= N && t(s2 + j) != p) tn[s2 + j] = true;
        }
    }

    int res = 0;
    for (int i = 2; i <= N; i++)
        if (!tn[i]) res++;

    std::cout << res << '\n';
    std::cerr << clock() * 1. / CLOCKS_PER_SEC;
    return 0;
}

PE433 Steps in Euclid's Algorithm

date: 26.1.13 ~~diff: 65~~ level: 30

题意：考察欧几里得算法求 $\gcd(x,y)$ 的流程：

令 $(x_0, y_0)=(x, y)$；

递推计算 $(x_k, y_k)=(y_{k-1}, x_{k-1}\bmod y_{k-1})$；

最终得到 $(x_n, y_n)=(\gcd(x,y),0)$。

令 $E(x,y)=n$，即使用欧几里得算法求 $\gcd(x,y)$ 的运算步数。令 $S(N)=\sum_{1\le x,y\le N} E(x,y)$。

求 $S(5\times 10^6)$。已知 $S(1)=1, S(10)=221, S(100)=39826$。

神秘论文题。reference: https://link.springer.com/content/pdf/10.1007/978-1-4615-4819-5_7.pdf

首先显然根据对称性：

$$ S(N)=\frac{N(N+1)}2+2\sum_{1\le y<x\le N}E(x,y) $$

论文中有结论，对 $n>2$：

$$ f(n)=\sum_{1\le y<n}[n\perp y]E(n,y)=\frac32\varphi(n)+2r(n) $$

其中：

$$ r(n)=\sum_{x<y,x'<y'}[x\perp y][x'\perp y'][xx'+yy'=n] $$

对该结论的证明（upd 1.17）

我们知道欧几里得算法等价于用连分数表示 $\frac ab=[a_1,a_2,\dots,a_k]$。考虑将 $E(a,b)$ 转换为这样的 $k(a,b)$。

首先规定 $a>b$，这样就有 $a_1\ge 1$。再规定 $a,b$ 互质且 $a_k>1$，于是连分数的表示唯一。这样直接能得到 $E(a,b)=k(a,b)$，并且所有 $a_i\ge 1$。

为了考察连分数的性质，我们引入 continuant（《具体数学》中译作“连项式”）。关于一系列变量 $a_1,a_2,\dots,a_n$ 的 continuant $K(a_1,a_2,\dots,a_n)$ 是被如下定义的多项式：

$n=0$ 时，$K=1$；
$n=1$ 时，$K(a_1)=a_1$；
$n\ge 2$ 时，有如下递归定义：

$$ K(a_1,\dots,a_n)=a_n K(a_1,\dots,a_{n-1})+K(a_1,\dots,a_{n-2}) $$

以下对某个给定的数列 $\{a_n\}$，记 $Q(l,r)=K(a_l,\dots,a_r)$。

Continuant 的重要用处是，其可以表示连分数。具体而言有：

$$ [a_1,\dots,a_n]=\frac{Q(1, n)}{Q(2,n)} $$

Euler 的研究指出，如果从中间拆开 continuant，会有如下性质：

$$ Q(1,n)=Q(1,i)\cdot Q(i+1,n)+Q(1,i-1)\cdot Q(i+2,n) $$

从 continuant 的形式不难发现 $K(a_l,a_{l+1},\dots,a_r)=K(a_r,a_{r-1},\dots,a_l)$。于是设：

$$ [a_i,a_{i-1},\dots,a_1]=\frac xy,\quad [a_{i+1},a_{i+2},\dots,a_n]=\frac{x'}{y'} $$

那么有：

$$ x=Q(1,i)\quad y=Q(1,i-1)\quad x'=Q(i+1,n)\quad y'=Q(i+2,n) $$

如果此时设数列 $\{a_n\}$ 满足 $\frac ab=[a_1,a_2,\dots,a_n]$，那么就有：

$$ a=xx'+yy' $$

根据连分数性质，显然会有 $x\perp y,x'\perp y',x'<y'$。同时，只需要 $[a_i,\dots,a_1]>1$ 就会有 $x<y$，这仅当 $a_1=i=1$ 时可能发生。

现在我们可以开始计数。固定 $a$，枚举 $b$，来对 $a=Q(1,k(a,b))$ 的拆分计数：$i\in[2,k-1]$ 显然合法，再判断 $i=1$ 时是否有 $a_i=1$ 即可。即总切分数为：

$$ C=\sum_{b\perp a}k(a,b)-1-[a_i=1]=\sum_{b\perp a}E(a,b)-\varphi(a)-\sum_{b}[a_i=1] $$

显然有 $a_i=1$ 当且仅当 $\lfloor a/b\rfloor =1$，这样的 $b$ 共 $\frac{\varphi(a)}2$ 个。即 $C=f(a)-\frac32\varphi(a)$。

我们再考虑，之前将每一种拆分对应到了一个 $(x,y,x',y')$。但是注意到 $\frac xy$ 有两种连分数表示（因为没有规定末项 $a_1>1$），故每个四元组 $(x,y,x',y')$ 对应两个拆分。即 $C=2r(a)$。

综上，我们得到

$$ f(a)=\frac32\varphi(a)+2r(a) $$

化简一下 $f$，去掉互质的要求：

$$ g(n)=\sum_{1\le y<n}E(n,y)=\lfloor 3(n-1)/2\rfloor + 2\tilde r(n) $$

其中：

$$ \tilde r(n)=\sum_{x<y,x'<y'}[x\perp y][xx'+yy'=n] $$

回到和式，就变成简单莫反了。

$$ \begin{aligned} \sum_{1\le y<x\le N}E(x,y) =&\ \sum_{x=2}^Ng(x)\\ =&\ \sum_{x=2}^N\lfloor 3(x-1)/2\rfloor + 2\sum_{x<y,x'<y'}[x\perp y][xx'+yy'\le N]\\ =&\ \sum_{x=2}^N\lfloor 3(x-1)/2\rfloor + 2\sum_{d}\mu(d)\sum_{x<y,x'<y'}[xx'+yy'\le N/d] \end{aligned} $$

还需要计算 $\sum_{x<y,x'<y'}[xx'+yy'\le n]$。枚举 $P=xx'\le(n-1)/2=L$，将 $y>x,y'>x'$ 的限制利用容斥拆开：

$$ \begin{aligned} &\ \sum_{x<y,x'<y'}[xx'+yy'\le n]\\ =&\ \sum_{xx'\le L}\left(\sum_{y,y'}[yy'\le n-xx'](1-[y\le x] - [y'\le x']+[y\le x,y'\le x'])\right)\\ =&\ \sum_{xx'\le L}\left(D(n-xx')-\sum_{y\le x}\lfloor\frac{n-xx'}{y}\rfloor-\sum_{y'\le x'}\lfloor\frac{n-xx'}{y'}\rfloor+xx'\right)\\ =&\ \sum_{P=1}^{L}\left(d(P)D(n-P)+d(p)P-2\sum_{x\mid P}\sum_{y\le x} \lfloor\frac{n-P}{y}\rfloor\right) \end{aligned} $$

其中 $d(n)=\sum_{d\mid n}1,D(n)=\sum_{i=1}^nd(i)$。前面两项容易计算。最后一项拎出来计算：

$$ \begin{aligned} \sum_{P=1}^{L}\sum_{x\mid P}\sum_{y\le x}\lfloor\frac{n-P}y\rfloor =&\ \sum_{x=1}^L\sum_{k=1}^{L/x}\sum_{y=1}^x\lfloor\frac{n-kx}{y}\rfloor\\ =&\ \sum_{y=1}^L\sum_{k=1}^{L/y}\sum_{x=y}^{L/k}\lfloor\frac{n-kx}{y}\rfloor\\ =&\ \sum_{y=1}^L\sum_{k=1}^{L/y}\sum_{x=0}^{L/k-y}\lfloor\frac{n-k(L/k)+kx}{y}\rfloor \end{aligned} $$

最内层的一个和式可以类欧 $O(\log n)$ 计算。枚举外面的两层进行求和，复杂度总共为 $O(n\log^2 n)$。

复杂度（设 $f(n)=O(n\log^2 n)$）：

$$ T(N)\approx O\left(\sum_{n\le \sqrt N}f(n)+f(N/n)\right)=O(N\log^3 N) $$

code

#include <iostream>
#include <vector>

typedef long long ll;

const ll N = 5e6;

std::vector<int> primes, mu;
std::vector<ll> d, D;

void Init(int n) {
    std::vector<bool> isp(n + 5, true);
    std::vector<int> e(n + 5);
    mu.resize(n + 5), d.resize(n + 5), D.resize(n + 5);

    mu[1] = d[1] = e[1] = 1;

    auto append = [&](int p) {
        primes.push_back(p), mu[p] = -1, d[p] = 2, e[p] = 1;
    };

    for (int i = 2; i <= n; i++) {
        if (isp[i]) append(i);
        for (int p : primes) {
            if (i * p > n) break;
            isp[i * p] = false;

            if (!(i % p)) {
                mu[i * p] = 0;
                d[i * p] = d[i] / (e[i] + 1) * (e[i] + 2);
                e[i * p] = e[i] + 1;
                break;
            }

            mu[i * p] = -mu[i];
            d[i * p] = d[i] * 2, e[i * p] = 1;
        }
    }

    for (int i = 1; i <= n; i++)
        D[i] = D[i - 1] + d[i], mu[i] += mu[i - 1];
}

ll f(ll a, ll b, ll c, ll n) {
    if (!a) return b / c * (n + 1);
    if (a >= c || b >= c)
        return n * (n + 1) / 2 * (a / c) + b / c * (n + 1) +
               f(a % c, b % c, c, n);
    ll m = (a * n + b) / c;
    return n * m - f(c, c - b - 1, a, m - 1);
}

ll S(int n) {
    ll res = 0, T = 0, L = (n - 1) / 2;
    for (int p = 1; p <= (n - 1) / 2; p++)
        res += d[p] * (D[n - p] + p);

    for (int y = 1; y <= L; y++)
        for (int t = L / y, k = 1; k <= t; k++)
            T += f(k, n - L / k * k, y, L / k - y);
    return res - 2 * T;
}

int main() {
    Init(N);

    ll ans = N * (N + 1) / 2;

    for (int i = 2; i <= N; i++)
        ans += 3LL * (i - 1) / 2 * 2;

    for (int r, t, l = 1; l <= N; l = r + 1) {
        t = N / l, r = N / t;
        ans += 4LL * S(t) * (mu[r] - mu[l - 1]);
    }

    std::cout << ans << '\n';

    std::cout << clock() * 1. / CLOCKS_PER_SEC << '\n';
    return 0;
}

PE443 GCD Sequence

date: 26.1.16 ~~diff: 30~~ level: 10

题意：$g(4)=13$, $g(n)=g(n-1)+\gcd(g(n-1), n)\quad(n\ge 5)$。

已知 $g(1000)=2524, g(1000000)=2624152$。求 $g(10^{15})$。

观察数列的前几项，发现经常出现连续数字，说明这一段中的递推式中的 $\gcd$ 项都为 $1$。如果我们能知道这一段的长度，就可以快速地跳过这一段。

假设这一段中的第一项为 $g(m)=m+k$。我们需要找到最小的 $t$，使 $\gcd(g(m+t),m+t+1)=\gcd(k-1,m+t+1)>1$。这里没有什么好方法，把 $k-1$ 所有的因数试一遍即可。

这个数列的行为不太好估计。体感复杂度不太低，但是跑起来很快，几秒就出来了。

PE266 Pseudo Square Root

date: 1.20 ~~diff: 65~~ level: 29

令 $p$ 为所有不超过 $190$ 的素数之积。求 $p$ 不超过其平方根的最大因子。

已完成今日看不懂 pe 难度评分大学习。

$190$ 以内共 $n=42$ 个素数。取对数之后 meet-in-the-middle 搜即可。复杂度 $O(n2^{n/2})$。

冒泡潜水

Unknown — Wed, 10 Dec 2025 00:00:00 +0000

填一个坑。这个鸽了三年多了。

Preface

众所周知，Pollard-Rho 能以 $O(n^{1/4}\log n)$ 的时间复杂度（通过一定优化能做到 $O(n^{1/4})$）找到合数 $n$ 的一个非平凡因子。但事实上，我们有更快的方法做到这件事。

本篇文章将介绍一种亚指数级复杂度分解质因数的算法：二次筛法（Quadratic Sieve, QS）。

注：

本篇文章中的复杂度分析将不包含对大整数进行运算的开销。
本篇文章偏教程向，会混杂很多比较 trivial 的内容。
其实我自己写的代码基本是贺的 zzt 的提交并加以修改。

Smooth Numbers

数论中，一般认为素数的性质是比较好的。比较自然地，研究合数时，我们会希望研究那些“比较素”的合数。

对这样比较好的合数的刻画，容易会想到，使用素因子较少的合数。但这显然是荒谬的，因为质因数分解并不容易：对于大素数 $p,q$，合数 $n=pq$ 很难被逆向表示为 $p,q$。

因而，我们转向另一个方向：研究素因子较小的合数，这便引出了 smooth numbers。

称一个数是 $y\text{-smooth}$ 的，当且仅当其所有质因子不超过 $y$。

容易发现，smooth number 的一个很好的性质是，它们容易被分解。我们只需简单筛出不超过阈值 $y$ 的素数 $p_1,p_2,\dots,p_k$，便能通过简单的试除法（因为 $y$ 相对较小，这些开销是可以承受的）确定 $n$ 的分解。

于是，我们会萌生一个想法：对于不 smooth 的 $n$，我们能否通过某些方法将其转化为比较 smooth 的数，再对其进行操作？想必，转化之后的操作应当是简单的。

事实上，数论中许多算法，如 Index Calculus 和本篇文章所要介绍的 Quadratic Sieve 都基于这样的转化。

Smooth Number 的密度

Smooth number 的密度由 Dickman 函数给出：

$$ \psi(x,y):=\left|\left\{i\le x\mid i \text{ is } y\text{-smooth}\right\}\right| $$

当 $x\to\infty$ 时，有：

$$ \psi(x,y)\sim x \rho(u)\quad\text{where }x=y^u $$

其中 $\rho(u)$ 是 Dickman-de Brujin 函数。这表明，当 $x$ 足够大时，smooth number 的密度不依赖于具体的 $x,y$，而只和 $u=\frac{\ln x}{\ln y}$ 有关。

Dickman 证明了如下估计：

$$ \rho(u)\approx u^{-u+o(u)} $$

证明涉及微分学，这里不作详细展开。

Quadratic Sieve

Dixon's Random Square Method

我们的算法基于以下思想：若能找到 $\alpha^2\equiv \beta^2\pmod N$ 且 $\alpha\not\equiv\pm \beta$，那么 $\gcd(\alpha+\beta,N)$ 能够给出一个 $N$ 的非平凡因子。问题在于，我们如何生成这样的 $\alpha, \beta$。

一个比较简单的想法是随机。我们随机这样的一个 $\alpha_i$ 并计算 $\gamma_i:=\alpha_i^2\bmod N$，这是一个模 $N$ 意义下的二次剩余。我们希望找到 $\gamma_i$ 的一个非平凡平方根 $\beta_i$。假定 $\gamma_i\perp N$，那么 $N$ 的每个质因子对应了 $x^2\equiv \gamma_i$ 的两个根，因而找到的 $\beta_i\equiv\pm \alpha_i$ 的概率只有 $\frac{1}{2^{\omega(N)-1}}\le \frac 12$。

理想情况下，若 $\gamma_i$ 是比较 smooth 的，我们可以对其分解 $\gamma_i=\prod p_j^{e_{i,j}}$。若 $\forall j$ 有 $2\mid e_{i,j}$，那么我们可以轻易地令 $\beta_i=\prod p_j^{e_{i,j}/2}$，这便得到一组 $\alpha,\beta$。

当然，我们运气应当不致于这么好，不仅 $\gamma_i$ 是 smooth 的，而且 $e_{i,j}$ 都是偶数。前者我们只能寄希望于概率，但是后者我们可以想想办法。考虑选取多个 $\alpha_i$ 并计算 $\gamma_i$，再令向量 $\boldsymbol v_i=(e_{i,1}\bmod 2,e_{i,2}\bmod 2,\dots,e_{i,k}\bmod 2)\in \mathbb Z_2^n$。如果我们能找到一些线性相关的 $\boldsymbol v_i$，即存在指标集 $I$ 使得 $\sum_{i\in I}\boldsymbol v_i=\boldsymbol 0$，那么可以取

$$ \begin{aligned} \alpha:=&\prod_{i\in I}\alpha_i\\\ \gamma:=& \prod_{i\in I}\gamma_i=\prod p_j^{\sum_{i\in I} e_{i,j}}\\ \beta:=&\prod p_j^{\left(\sum_{i\in I}e_{i,j}\right)/2} \end{aligned} $$

一般的实现中，可以令 $\beta_i:=\prod p_j^{\left\lfloor e_{i,j} / 2\right\rfloor}$，那么就有：

$$ \beta=\prod_{i\in I} \beta_i\cdot\prod p_j^{\left(\sum_{i\in I}e_{i,j}\bmod 2\right) / 2} $$

假设选取的 smooth 阈值为 $B$，那么我们就是有若干个 $\pi(B)$ 维的向量。只要我们找到 $\pi(B)+k$ 个向量，我们就能通过高斯消元找出 $k$ 组 $\alpha,\beta$，每组至少有 $\frac 12$ 概率成功分解，那么总的分解成功概率就是 $1-2^{-k}$。

复杂度分析

~~我被一篇傻逼文献骗了好久~~

显然该方法的复杂度依赖于阈值 $B$ 的选取。为方便计算，令 $k = \pi(B),u=\frac{\ln N}{\ln B}$。

$\gamma_i=\alpha_i^2\bmod N$ 是模 $N$ 的二次剩余，它大约在 $1\sim N$ 中均匀分布，因此我们可以用前面的 smooth number 密度公式估算它 smooth 的概率，即 $u^{-u}$。我们需要找到 $O(k)=O\left(\frac{B}{\ln B}\right)$ 个向量。每次尝试需要 $k$ 次试除。最后，我们需要进行高斯消元。故可得到：

$$ T\approx k^2u^u+k^3 $$

这种式子谁爱算谁算，我扔给 AI 了。算出来 $T$ 最小时有：

$$ B\approx \exp(\frac 1{\sqrt2}\sqrt{\ln N\cdot\ln\ln N}) \\ T\approx\exp(\frac 3{\sqrt2}\sqrt{\ln N\cdot\ln\ln N}) $$

The L-notation

细心的读者容易发现上面的 $B$ 和 $T$ 有相似的结构。事实上，这种结构的渐进表示在 smooth number 相关算法中相当常见。

一般地，我们定义 L-notation：

$$ L_n[\alpha, c]:=\exp\left(\left(c+o(1)\right)\left(\ln n\right)^\alpha\left(\ln \ln n\right)^{1-\alpha}\right)\quad \text{where }c>0, 0\le\alpha\le1 $$

该函数的增长量级主要由 $\alpha$ 控制：

$\alpha=1$ 时，$L_n[1,c]=O\left(n^{c+o(1)}\right)$（指数级复杂度）
$\alpha=0$ 时，$L_n[0,c]=O\left((\ln n)^{c+o(1)}\right)=O(\text{polylog})$
$\alpha\in(0,1)$ 时，$L_n[\alpha,c]$ 表示亚指数级复杂度。

于是我们可以重新表示上面结果中的 $B,T$：

$$ B=L_N\left[\frac 12,\frac1{\sqrt 2}\right]\\ T=L_N\left[\frac 12,\frac3{\sqrt2}\right] $$

读者可以自行尝试证明该算法复杂度的另一种方法：设 $B=L_N[1/2,c]$ 并带入以上复杂度式子，解出 $c$。

Optimized Dixon

朴素的 Dixon 方法使用了随机选取的 $\alpha$，因而 $\gamma:=\alpha^2\bmod N$ 的 smoothness 似乎没有保证。我们会希望使用更好的 $\alpha$ 来优化这一点。

一个比较显然的想法是选择 $\alpha_i=\left\lceil \sqrt N\right\rceil+i$。当 $i$ 不太大时，这样得到的 $\gamma_i\sim2i\sqrt N$ 比较小，应当会比较 smooth。

假设我们需要 $M$ 个这样的 $\alpha_i$，那么应当有 $\gamma_i \sim 2M\sqrt N$，以这个数为上限套用之前的 smooth number 密度公式，计算得到，当 $B=L_N[1/2,1/2]$ 时，有 $T\approx L_N[1/2,3/2]$。

一个未作太多优化的实现

QS

以上的算法在 $N\approx 10^{30}$ 时就略显吃力。我们当然不满足于此。

注意到上面算法的复杂度瓶颈在于，对于每个 $\alpha_i$，我们都必须通过试除法确定 $\gamma_i$ 是否是 smooth 的。由于选取合适的 $\alpha_i$ 需要大量的尝试，这样反复试除的开销会变得不可接受。考虑如何减少试除次数。

我们都知道求质数可以用筛法，其实求 smooth 数也可以。更进一步，我们还可以筛多项式（因为 $p\mid f(c)\Leftrightarrow p\mid f(kp+c)$），比如一般的埃氏筛就是在筛 $f(i)=i$（如果跳过偶数可看作在筛 $f(i)=2i+1$）。

考察这样一个多项式：$f(x)=x^2-N$。当 $i$ 较小时，有 $f\left(\left\lceil\sqrt N\right\rceil+i\right)=\alpha_i^2\bmod N$。我们希望筛一下它来优化上面的 Optimized Dixon 中的试除法。

类似埃氏筛地，我们枚举小质数 $p$。若 $p^k\mid f(i)$ 就将 $p^k$ 从 $f(i)$ 的值中除去，筛完一遍变成 $1$ 的就是 smooth 的 $f(i)$。若我们有 $c$ 是 $N$ 在模 $p$ 意义下的二次剩余，那么当且仅当 $x\equiv \pm c\pmod p$ 时会有 $p\mid f(x)$，枚举每个 $x$ 并筛去 $p$ 即可。

一个实现

优化

对 QS 的改进方案中，提升较大的是选择更好的多项式去筛，这点留待后文详叙。这里讲几个小优化。

$f(i)$ 和 $f(-i)$ 可以一起筛。注意消元的时候要把负号消掉。
注意到 $p\mid f(i)$ 当且仅当 $N$ 是模 $p$ 意义下的二次剩余，因此在筛小素数时可以算一下 Legendre 符号 $\left(\frac Np \right)$，如果不为 $1$ 这个素数就是没用的。
如果 $f(i)$ 除掉小质数还剩一个不太大的数（一般的阈值是 $B^2$），可以把剩下这个值扔到 std::unordered_map 里。如果后面找到的 $f(j)$ 剩下同样的数，那么可以使用 $f(i)f(j)$，这个剩下的值就被平方了，乘到 $\beta$ 里即可。（Lenstra 等提出，数据范围足够大时，可以尝试将除剩下的数分解为两个不大于 $B^2$ 的数的乘积，并放到图上求解^[1]）
为了节省空间，我们在筛 $f$ 时通常无法直接算出 $\beta_i$ 和 $\boldsymbol v_i$，而需要对筛出的 smooth 的 $f$ 再进行一次试除。这就使得筛 $f$ 时的一堆大整数除法有点意义不明。可以考虑使筛 $f$ 的条件变松：我们计算其对数，如果 $\log f(i) $ 减去 $ \sum_{p_j\mid f(i)}\log p_j$ 比较小，那么这个 $f(i)$ 大概会比较 smooth，再对其进行试除即可。
朴素的高斯消元会成为算法的复杂度瓶颈。注意到 $\boldsymbol v_i$ 中至多有 $O(\log N)$ 个数非零，这说明我们最终要进行高斯消元的矩阵是一个稀疏矩阵。可以使用 Block Wiedemann 或 Block Lanczos 算法（Montgomery 给出过一种为素因数分解特化的在 $GF(2)$ 上的 Block Lanczos^[2]）将消元部分复杂度降至 $O(k^2\log N)$。实现中可以使用 std::bitset 优化的在线高斯消元，性能不会有明显劣势。

复杂度分析

同 Dixon，我们需要筛出 $O(k)$ 个数，每个数成功概率为 $u^{-u}$，筛每个数的成本为 $\sum_{p\le B}p^{-1}=O(\log\log B)$。高斯消元复杂度 $O(k^2\log N)$。故有：

$$ T\approx ku^u\log\log B+k^2\log N $$

当 $T$ 最小时，有：

$$ B\approx \exp(\frac 12\sqrt{\log N\log\log N})=L_N\left[\frac 12,\frac12\right]\\ T\approx\exp(\sqrt{\log N\log \log N})= L_N\left[\frac 12,1\right] $$

MPQS

Multiple Polynomial Quadratic Sieve，简称 MPQS ~~（标题冒泡潜水的由来）~~。

朴素 QS 的问题是，当 $N$ 较大时，我们需要筛的 $f(i)$ 个数（设为 $M$）会较大，而 $f(i)\sim 2M\sqrt N$ 也会较大，这使得 $f$ 较 smooth 的猜想不再成立。为了解决这个问题，Montgomery 提出：我们可以筛多个多项式。

具体而言，我们希望用一个线性函数 $ax+b$ 替代之前的 $x$，即考虑 $(ax+b)^2-N$。如果 $b^2\equiv N\pmod a$，那么 $(ax+b)^2-n$ 可以写成 $af(x)=a(ax^2+2bx+c)$ 的形式，其中 $b^2-ac=N$。为了方便处理，我们设 $a$ 是一个 smooth 数的平方（比如 $p^2$，也有文献建议取一系列小素数乘积的平方），那么我们只需要去筛 smooth 的 $f(x)$。

假设我们只去筛 $|x|\le M$ 的 $x$。与之前同样地，我们希望使 $|f(x)|$ 较小以使得其较 smooth。根据中学数学知识，我们会希望抛物线对称轴 $x=-\frac ba$ 靠近所筛区间 $[-M,M]$ 的中点 $x=0$，这要求 $b$ 较小。另外，我们希望区间端点和中点处 $|f(x)|$ 值相近，即 $|f(M)|\approx |f(0)|$，解出 $a\approx\frac{\sqrt{2N}}{M}$。

实现中，我们可以从 $\frac{(2N)^{1/4}}{M^{1/2}}$ 开始枚举小素数 $p$，令 $a=p^2$，取 $b$ 为 $b^2\equiv N\pmod a$ 的较小解，再算出 $c$。然后按照 QS 的方法筛 $(ax+b)^2-N$ 即可。

MPQS 相比于 QS 复杂度不变，但有较大常数优势。zzq 说有分析认为提升倍数是 $\frac 12\sqrt{\ln N\ln\ln N}$，我不知道是怎么算出来的。

zzt 的实现

HMPQS

The Hypercube variation of Multiple Polynomial Quadratic Sieve，简称 HMPQS。

Peralta 提出，MPQS 中切换多项式还要重算一遍 $b,c$ 之类的，比较麻烦。考虑生成一些有联系的多项式来消灭掉这个代价。~~其实和 Hypercube 没啥必然联系，Peralta 为了容易理解随便举的例子~~

我们发扬光大一下 MPQS 中的一个细节。令 $t$ 为 $n$ 个素数的乘积（$t:=\prod_{i=1}^nq_i$），且 $t\sim N^{1/4}$。假设 $a=t^2$，$b$ 为方程 $b^2\equiv N\pmod {t^2}$ 的一个解。显然这里 $b$ 有 $2^n$ 个解。我们希望这样所生成出的 $2^n$ 个 $(ax+b)^2$ 有比较好的性质。

首先考虑如何表示 $b$。由 CRT，只需解出 $\alpha_i^2\equiv N\pmod {q_i^2}$，那么就可以令 $b=\sum \delta_i\alpha_i\beta_i$，其中 $\delta_i=\pm1$，$\beta_i$ 是 CRT 算出的系数。$\alpha_i$ 有两个解，此处我们选择使得 $\gamma_i:=\alpha_i\beta_i\bmod t^2\le\frac{t^2}2$ 的解。

然后考虑如何遍历所有的 $b$。令数列 $s_1,\dots,s_{2^n}$ 遍历所有的 $b$ 解。我们希望遍历过程中每次只更改一个 $\delta_i$，那么可以有递推关系：

$$ s_{i+1}=s_i+2\mu_i\gamma_{k_i}-\omega_it^2 $$

其中 $\mu_i=\pm 1$，代表 $\delta_{k_i}$ 的改变。Peralta 的叙述中把这个递推关系理解为 $n$ 维 Hypercube 上的一个 Hamilton 路径，$\mu_i$ 代表第 $k_i$ 维坐标的改变；当然其实还有其他理解方法，比如相信大家都知道格雷码，原理是类似的。$\omega_i$ 可以理解为对 $t^2$ 取模的一个修正系数，使得 $s_{i+1}\in(0,t^2)$。由之前对 $\alpha_i$ 的选择，有 $\omega_i\in\{\pm 1,0\}$。一般的实现中可以直接取 $\omega_i\equiv 0$，此时仍有 $s_i\in(-nt^2,nt^2)$。

当然我们并不关心具体值。在筛法中，$s_i$ 作为多项式的系数，我们关心其模 $p$ 意义下的值。Peralta 提出，为了方便计算 $s_i\bmod p$，我们可以打表一下其差分。令：

$$ \Delta_i:=s_{i+1}-s_i=2\mu_i\gamma_{k_i}-\omega_it^2 $$

注意到 $\mu_i$ 有两种取值，$\omega_i$ 有三种取值，$\gamma_i$ 有 $n$ 种取值，那么 $\Delta_i$ 至多有 $6n$ 种取值（如果固定 $\omega_i=0$ 则只有 $2n$ 种）。这个可以打表算出来。那么转移就只需极小的代价。

现在可以构造我们需要的多项式了。对 MPQS 中的多项式略作变换，除掉 $a$ 这个平方因子，就得到我们构造的多项式：

$$ \begin{aligned} f_i(x):=&\ (s_i/t+x t)^2\bmod N\\ =&\ \frac{s_i^2-N}{t^2}+2s_ix+x^2t^2 \end{aligned} $$

我们仍须验证这样生成的 $f_i(x)$ 不太大，以保证其 smooth 的概率。假设我们要筛的区间是 $x\in[-M,M]$，我们取 $t\le\frac{N^{1/4}}{\sqrt M}$。由于 $s_i^2<t^4<N$，通过简单放缩可以得到 $\frac{s_i^2-N}{t^2}<0$ 且 $\left|\frac{s_i^2-N}{t^2}\right|\le M\sqrt N$。二次项 $x^2t^2\le M^2\left(\frac{N^{1/4}}{\sqrt M}\right)^2=M\sqrt N$。一次项 $2s_ix\le 2M\sqrt N$。因此我们大概有 $f_i(x)=O(M\sqrt N)$，这说明其值不太大，也就保证其大概比较 smooth。

在筛法中，令 $p\mid f_i(x)$，容易得到 $x\equiv(-s_i\pm\sqrt N)t^{-2}\pmod p$。这就得到筛 $f_i(x)$ 的两个起点：

$$ D_i=(-s_i+\sqrt N)t^{-2}\bmod p\\ E_i=(-s_i-\sqrt N)t^{-2}\bmod p=(D_i-2\sqrt Nt^{-2})\bmod p $$

$s_i\bmod p$ 容易由上述递推算出。如果预先算出 $\sqrt N\bmod p, t^{-2}\bmod p,2\sqrt Nt^{-2}\bmod p$，就可以很快算出 $D_i,E_i$。这就节省了切换多项式的时间。

还剩下最后一个细节：如果 $p\mid t$，那么以上同余式的推导不成立。事实上，当 $p\mid t$ 时，当且仅当 $x\equiv -\frac{(s_i^2-N)/t^2}{2s_i}\pmod p$ 时有 $p\mid f_i(x)$，即某个 $x$ 使得 $p\mid f_i(x)$ 的概率减半为 $1/p$。这提示我们，$t$ 的因数尽量不要选取 smooth check 所使用的小素数，以增大 $f_i(x)$ smooth 的概率。实现中，我们可以选择素数 $q\in[B,2B]$ 来生成 $t$，这样大约有 $n\approx\log_B N\approx2\sqrt\frac{\log N}{\log\log N}$。

~~我并没有写这个的代码~~

References:

zzq's blog
Quadratic Sieve - Wikipedia
Prime Numbers: A Computational Perspective (Crandall, Pomerance)（zzq 那篇的 reference）
A Quadratic Sieve on the n-Dimensional Cube (Peralta)

Factoring with Two Large Primes (Lenstra, Manasse) ↩
A Block Lanczos Algorithm for Finding Dependencies over GF(2) (Montgomery) ↩

模法

Unknown — Wed, 23 Jul 2025 00:00:00 +0000

因为滚去 whk 鸽了两年的 Montgomery 取模。

众所周知取模很慢，因为一般的除法很慢。但是除一个 $2$ 的幂或者对它取模很快。考虑将对固定模数 $p$ 的取模转化成对一个 $r=2^k$ 的除法和取模操作。要求 $p$ 与 $r$ 互质，具体使用中 $p$ 通常是奇素数，显然满足要求。

由 $p$ 与 $r$ 互质，$\{xr\mid 0\le x<p\}$ 是一个模 $p$ 的完全剩余系。考虑用 $r(x)=xr\bmod p$ 进行一些操作。

为了快速计算 $r(x)$，考察一个很邪恶的函数。令 $r^{-1}$ 为模 $p$ 意义下 $r$ 的逆元，定义 $redc(x)=xr^{-1}\bmod p$。redc 是 reduce 的缩写，~~Montgomery 的论文里这么写的~~。先计算 $redc(x)$。把取模用不定方程替代掉：

$$ r\cdot redc(x) + kp=x \\ redc(x)=\frac{x-kp}{r} $$

然后考察 $k$。由 $r$ 的性质，自然想到对 $r$ 取模：

$$ kp\equiv x\pmod r \\ k=xp^{-1} \bmod r $$

由于模数固定，$p^{-1}$ 可以预处理。这样算 $redc(x)$ 就可以用两次乘法和一些移位搞定了，很快。注意稍微处理一下，保证 $redc(x)\in[0,p)$。于是 $r(x)$ 也很好算：$r(x)=redc(xr^2)$。可以预处理一下 $r^2\bmod p$。

接着观测一下 $r(x)$ 的性质。显然 $r(x\pm y)=r(x)\pm r(y)$。对乘法有 $r(xy)=\frac{r(x)r(y)}{r}=redc\left(r(x)r(y)\right)$。所以可以直接用 $r(x)$ 代替 $x$ 进行计算。从 $r(x)$ 还原时有 $x=redc(r(x))$。

需要预处理 $p^{-1}\bmod r$ 和 $r^2\bmod p$。前者可以对 $f(x)=\dfrac{1}x-p$ 牛迭得到，每次令 $x'=2x-x^2p$ 即可。后者没啥好办法，直接算吧。

复杂度 $O\left(\dfrac{\log^2p}{w}\right)-O\left(\dfrac{\log^2p}{w^2}\right)$，神速。

贴一下 zzt 在 Loj#6466 的实现并且稍微解释一下：

struct u256 {
	u128 lo, hi;
	u256() {}
	u256(u128 lo, u128 hi) : lo(lo), hi(hi) {}
	static u256 mul128(u128 a, u128 b) {
		u64 a_hi = a >> 64, a_lo = u64(a);
		u64 b_hi = b >> 64, b_lo = u64(b);
		u128 p01 = u128(a_lo) * b_lo;
		u128 p12 = u128(a_hi) * b_lo + u64(p01 >> 64);
		u64 t_hi = p12 >> 64, t_lo = p12;
		p12 = u128(a_lo) * b_hi + t_lo;
		u128 p23 = u128(a_hi) * b_hi + u64(p12 >> 64) + t_hi;
		return u256(u64(p01) | (p12 << 64), p23);
	}
} ;

struct Mont {
	u128 mod, inv, r2;
	Mont(u128 n) : mod(n) {
		assert(n & 1);
		inv = n;
		for (int i = 0; i < 6; ++i) inv *= 2 - n * inv;
		r2 = -n % n;
		for (int i = 0; i < 4; ++i) if ((r2 <<= 1) >= mod) r2 -= mod;
		for (int i = 0; i < 5; ++i) r2 = mul(r2, r2);
	}
	u128 reduce(u256 x) const {
		u128 y = x.hi - u256::mul128(x.lo * inv, mod).hi;
		return i128(y) < 0 ? y + mod : y;
	}
	u128 reduce(u128 x) const { return reduce(u256(x, 0)); }
	u128 init(u128 n) const { return reduce(u256::mul128(n, r2)); }
	u128 mul(u128 a, u128 b) const { return reduce(u256::mul128(a, b)); }
} mont(1);

u256 是一个压位 u128，$x=hi\times2^{128}+lo$。

Mont 是 Montgomery 乘法封装成一个结构体。mod 是模数 $p$，inv 是 $p^{-1}\bmod r$，r2 是 $r^2\bmod p$。但是这个 r2 的初始化我没看懂。assert 用来特判偶数，但是这题数据好像没偶数。

使用时先 mont=Mont(p)，每个数都先 x=mont.init(x) 一下。乘法直接 prod=mont.mul(a,b)。还原的时候 mont.reduce 一下自己就行。