从素数判定到欧拉筛：数论基础与线性筛实战全解析

聊到数论基础，几乎所有人都绕不开素数。判断一个数是不是素数、筛出一段范围内的所有素数、用素数做唯一分解，这些看起来是最入门的内容，但真正落地到代码里，从暴力试除到欧拉筛，每一步都有讲究。今天我就把这套东西一次性捋顺，从最朴素的定义出发，最后落到线性筛的完整实现，顺便把欧拉筛为什么快、怎么用好、踩过哪些坑一起说清楚。无论你是刚学算法的新手，还是想在竞赛里稳定输出数论题的选手，这篇都值得耐心看完。

1. 素数定义与那些容易被忽略的边界

素数又叫质数，定义很朴素：在大于1的自然数中，如果一个数除了1和它本身之外没有其他因数，那它就是素数。反过来，如果它有除1和自身以外的因数，就叫合数。这个定义几乎人人会背，但真到写代码的时候，好几个边界点特别容易翻车。

1.1 定义中的三个易错点

第一，1既不是素数也不是合数。这不是废话，很多新手刚写isPrime函数时，先判断n是否为1，然后顺手return true，结果一交上去就WA。在你自己的本地环境里，把1当成素数可能影响不大，因为单次判断只错一个数；但如果配合前缀和、计数、筛法使用，一个边界错，整个统计结果全偏。

第二，2是最小的素数，也是唯一的偶素数。这意味着在写判断函数时，n=2要单独照顾，不能一进函数先判断n%2==0就返回false。很多优化写法是从“跳过偶数”开始的，但2这个特例必须在前面处理掉。

第三，负数、0、小数都不在讨论范围内。数论题的输入通常保证为正整数，但保险起见，函数入口统一加一句if (n < 2) return false;，成本极低，能挡住不少隐藏测试数据。曾有人在本地测试全是正整数，结果OJ里藏了一组0和1的边界，直接吃了个WA。

1.2 为什么判断到根号n就够了

先解释一个最核心的问题：判断n是否为素数时，为什么只需要从2试到sqrt(n)就够，而不是试到n-1？

假设n是一个合数，那么它一定可以写成两个大于1的整数相乘：n = a * b。如果a和b都大于sqrt(n)，那么a * b > sqrt(n) * sqrt(n) = n，这显然矛盾。所以a和b中至少有一个不大于sqrt(n)。换句话说，只要n存在因数，就必然存在一个不超过sqrt(n)的因数。我们只需要在[2, sqrt(n)]范围内找一遍，找不到，n就是素数。

这个结论直接决定了暴力试除法的复杂度是O(sqrt(n))。在n是10^12级别时，sqrt(n)=10^6，暴力判断完全可行；但如果n到10^18，sqrt(n)=10^9，暴力就不太行了，得另想办法，这在竞赛里属于Miller-Rabin的领域，今天不展开，但你要知道试除法的能力边界。

1.3 一个有趣的结论：6x-1形式的素数

搜索热词里出现“6x-1的素数有无穷多”，这其实是个很经典的数论结论，属于狄利克雷定理在公差6情况下的特例：形如6k-1的素数有无穷多个。同理，形如6k+1的素数也有无穷多个。

这个结论在刷题时很少直接考证明，但它的意义在于提示一个规律：除2和3之外，所有素数都落在6k-1或6k+1这两种形式里。原因是，任何整数对6取模后只可能余0、1、2、3、4、5，余0、2、4对应偶数，余3对应3的倍数，这些都不可能成为大于3的素数，因此剩下的只能是6k±1。这个规律就是下一节要讲的6k±1优化的数学依据。

2. 单个素数判断：从暴力试除到6k±1优化

单个素数判断是最常见的入门题型，也是后面筛法的基础。这一节我把写法一层层递进，从最慢但最不容易错的版本，一直优化到竞赛里常用的版本。

2.1 暴力试除与正确写法

最直接的想法，就是从2一直试到n-1，看n是否能被其中某个数整除。代码长这样：

cpp复制bool isPrime(int n) {
    if (n < 2) return false;
    for (int i = 2; i < n; i++) {
        if (n % i == 0) return false;
    }
    return true;
}

这个写法的正确性是毫无疑问的，但效率很差，判断单个n是O(n)。如果n到10^7，循环一千万次，单次调用还能忍，如果套在循环里判断一万个数，那基本就跑不动了。

改进一步，利用上面的sqrt(n)结论，把循环范围从i < n改成i * i <= n：

cpp复制bool isPrime(int n) {
    if (n < 2) return false;
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) return false;
    }
    return true;
}

这里有个容易踩的坑：i * i可能溢出。当n是int范围内的数，i最大到46340左右时，i*i接近int上限，再往上就会溢出成负数，导致循环条件永远成立，程序死循环或者答案错乱。稳妥的做法是把i定义成long long，或者写成i <= n / i，从乘法比较改成除法比较，从根上规避溢出。

2.2 6k±1优化的原理与完整代码

再进一步，根据1.3节的结论，除2和3外，素数只可能以6k±1的形式出现。所以我们先单独处理n=2和n=3，然后把n能被2或3整除的情况直接排除，最后所有可能的因子都落在形如6k-1和6k+1的数上。对应的枚举方式就是i从5开始，每次加6，依次检查i和i+2。代码写出来长这样：

cpp复制bool isPrime(int n) {
    if (n < 2) return false;
    if (n == 2 || n == 3) return true;
    if (n % 2 == 0 || n % 3 == 0) return false;
    for (int i = 5; i * i <= n; i += 6) {
        if (n % i == 0 || n % (i + 2) == 0) return false;
    }
    return true;
}

为什么只检查i和i+2？因为i=5时，i+2=7，这两个数恰好是6k-1和6k+1的形式；下一个迭代i=11，i+2=13，依然是这个形式。这样每6个数里只检查2个候选因子，比逐个试除快了约3倍。虽然常数上不是巨大的飞跃，但代码几乎不增加复杂度，属于“白捡的优化”，竞赛里用这版非常合适。

有人会问：为什么不检查6k±1之外的其他数？因为它们必然是2或3的倍数，而我们在循环前就已经把n能被2或3整除的情况排除了，所以n的因子不可能落在这些位置。逻辑闭环。

2.3 什么时候用单个判断而不是筛法

单个判断适合两种场景：一是n很大但查询次数很少，比如判断几个10^12级别的数，用6k±1试除就够了，筛法根本筛不到那么大；二是n很小，比如n不超过1000，暴力判断和筛法差距几乎感觉不到，怎么写都行。

如果题目是“给定一个上限N，需要频繁判断N范围内任意数是否为素数”，比如查询次数达到10^5以上，那就不要每次都跑sqrt(n)的试除，而是应该用筛法把整个区间的素数表先打出来，之后每次O(1)查询。这是两种思路的分水岭，选错方法，笔试和OJ评测就会一个超时一个通过。

3. 批量筛素数：埃氏筛的思路与代价

单点判断讲完了，接下来进入真正的高频考点：批量筛素数。场景通常是“求[2, n]范围内有多少个素数”，或者“预处理后回答大量素数查询”。

3.1 从判断到筛法的思维转换

如果还是用单个判断的思维，从2到n逐个调isPrime，整体复杂度是O(n * sqrt(n))。n=10^6时大概要跑10^9次取模，已经非常吃力；n再大一点就彻底没法用了。

筛法的核心思想完全反过来：不靠“判断某个数是不是素数”，而是靠“把所有合数标记出来”，剩下的自然就是素数。这就是“筛”这个名字的由来。就像你要在一堆沙子里找石子，不用一颗颗辨认沙子，直接拿筛子把所有沙子筛掉，剩下的就是石子。

3.2 朴素筛的写法与时间复杂度

最简单粗暴的筛法：从2开始，遇到一个数就把它的所有倍数都标记成合数。等处理完一遍，没被标记的数就是素数。

cpp复制vector<bool> isPrime(n + 1, true);
isPrime[0] = isPrime[1] = false;
for (int i = 2; i <= n; i++) {
    if (!isPrime[i]) continue;
    for (int j = 2 * i; j <= n; j += i) {
        isPrime[j] = false;
    }
}

这个写法在n很小时完全没问题，但n稍微大一点就明显变慢。原因很简单：一个合数会被它的好几个不同质因子重复标记。比如12，会在i=2时被26标记，也在i=3时被34标记，等于是做了两次无用功。整体标记次数约等于n * (1/2 + 1/3 + 1/5 + 1/7 + ...)，这个调和素数和的量级是n * log log n，虽然已经比n*sqrt(n)好了很多，但还是有大量冗余。

3.3 埃氏筛优化：从2i到ii

经典埃拉托斯特尼筛法在朴素筛基础上做了一步关键优化：内层循环不是从2i开始，而是从ii开始。

cpp复制vector<bool> isPrime(n + 1, true);
isPrime[0] = isPrime[1] = false;
for (int i = 2; i * i <= n; i++) {
    if (isPrime[i]) {
        for (int j = i * i; j <= n; j += i) {
            isPrime[j] = false;
        }
    }
}

为什么可以从ii开始？因为小于ii的i的倍数，例如2i、3i、4i、...、(i-1)i，一定存在一个小于i的质因子，也就是说它们已经被更小的质因数筛过了。以i=5为例，25在i=2时就被标记了，35在i=3时被标记了，45在i=2时就被标记了，根本轮不到i=5出手。所以从ii开始不仅正确，还省掉了大量重复操作。

另一个细节是外层循环只需要到sqrt(n)，道理和单个判断中的sqrt结论相同。在n=10^7时，这个优化能让整个筛法少跑很多轮，体感差距非常明显。

3.4 埃氏筛的复杂度分析与局限

埃氏筛优化后的时间复杂度是O(n * log log n)，实际运行起来，n=10^7时C++大概需要零点几秒，看起来很美好。但如果你追求极致，或者题目数据范围到了10^8甚至更高，埃氏筛的重复标记问题就显现出来了：12被2和3各标一次，30被2、3、5各标一次。标记次数虽然比朴素筛少，但并非严格线性。

这个“重复标记”就是埃氏筛和欧拉筛的分水岭。欧拉筛之所以叫“线性筛”，就是因为它的核心目标是把重复标记彻底消灭，让每个合数只被筛到一次，整体复杂度从n * log log n降到严格的O(n)。接下来这部分是整个数论基础里最值得吃透的内容之一。

4. 欧拉筛：让每个合数只被筛掉一次

欧拉筛也叫线性筛，它和埃氏筛最大的区别在于：埃氏筛用每个质数去标记它的所有倍数，而欧拉筛保证每个合数只被它的最小质因子标记一次。这个“最小质因子”的约束是全部精髓所在。

4.1 欧拉筛的核心思想

先用一句话概括欧拉筛的工作过程：从小到大遍历每个数i，如果i没被标记过，说明它是素数，加入素数表；然后遍历已经找到的素数表，用当前的i去乘这些素数，把乘积标记为合数；一旦i是当前素数的倍数，就立刻停止内层遍历。

关键就在最后那个停止条件：if (i % primes[j] == 0) break;。很多初学者抄了欧拉筛代码，但不知道为什么要有这一句，甚至觉得去掉也能跑。去掉确实也能跑出正确答案，但复杂度会退化，而且标记方式不再是最小质因子标记，失去了线性性质。

为什么i % primes[j] == 0时必须停？假设primes[j]是i的最小质因子，继续用更大的primes[j+1]去乘i，得到合数i * primes[j+1]。这个合数的最小质因子其实是primes[j]，而不是primes[j+1]。如果现在把它标记了，以后等i' = (i * primes[j+1]) / primes[j]的时候，还会再标记一次，重复标记就出现了，直线性被破坏。所以在遇到i的最小质因子时停住，才能保证同一个合数只交给“最小质因子场景”去标记。

4.2 手动模拟一次完整筛选过程

光讲理论不好懂，我拿n=20手动跑一遍欧拉筛，你立刻就能理解每个数是怎么被处理的。

初始：isComposite全为false，素数表为空。

i=2：2没被标记，加入素数表，primes=[2]。内层：j=0，筛掉2*2=4，即4被标记；此时2%2==0，break。

i=3：3没被标记，加入素数表，primes=[2,3]。内层：j=0，筛掉32=6，3%2!=0，继续；j=1，筛掉33=9，3%3==0，break。

i=4：4已被标记，不加素数表。内层：j=0，筛掉4*2=8，4%2==0，break。注意这里没有用4去乘3，否则会标记12，但12的最小质因子是2，应该留给后面的i=6处理。

i=5：5没被标记，加入素数表，primes=[2,3,5]。内层：筛掉52=10，5%2!=0；筛掉53=15，5%3!=0；筛掉5*5=25（超过20，循环条件判断后停止）。实际代码里25>n就直接退出了，所以内层在25处停止。

i=6：6已被标记。内层：j=0，筛掉62=12，6%2==0，break。这里如果继续用63=18去标记，就会出现重复，因为18的最小质因子是2，应该由i=9乘2得到。代码在这里break后，18不会被现在这个i=6标记，而是在i=9时通过9*2=18被标记。

i=7：7是素数，加入primes。内层：筛掉72=14，7%2!=0；73=21>20，退出。

i=8：已标记。内层：筛掉8*2=16，8%2==0，break。

i=9：已标记。内层：92=18被标记，9%2!=0；93=27>20，退出。

i=10：已标记。内层：10*2=20被标记，10%2==0，break。

最终没被标记的数：2、3、5、7、11、13、17、19，正好是20以内的全部素数。观察整个筛的过程，每个合数都只被标记了一次：4在i=2，6在i=3，8在i=4，9在i=3，10在i=5，12在i=6，14在i=7，15在i=5，16在i=8，18在i=9，20在i=10。完全没有重复。

4.3 为什么这样就能保证线性

简单推导一下整体复杂度：外层循环i从2到n，总共n次。内层循环每次执行，都会产生一个新的合数标记，同时以内层循环的break为出口。因为每个合数最多只被标记一次，而标记操作和内层迭代次数一一对应，所以内层总执行次数不会超过合数个数，也就是O(n)。再加上外层n次，总复杂度就是O(n)。

这是欧拉筛和埃氏筛最本质的区别：埃氏筛里一个合数被标记次数等于它的不同质因子个数，而欧拉筛里一个合数只有一次标记机会，所以从数学上保证了线性。在n=10^7时，欧拉筛比埃氏筛快出可感知的差距，n越大差距越明显。

4.4 完整代码与常见错误写法

一套可以直接用的欧拉筛模板如下：

cpp复制vector<int> primes;
vector<bool> isComposite(n + 1, false);

void linearSieve(int n) {
    for (int i = 2; i <= n; i++) {
        if (!isComposite[i]) {
            primes.push_back(i);
        }
        for (int j = 0; j < primes.size() && i * primes[j] <= n; j++) {
            isComposite[i * primes[j]] = true;
            if (i % primes[j] == 0) break;
        }
    }
}

如果想在后续查询时O(1)判断某个数是不是素数，可以不用isComposite这个浮空数组，而是用isPrime数组，在筛的过程中同步维护标记：

cpp复制vector<int> primes;
vector<bool> isPrime(n + 1, true);

void linearSieve(int n) {
    isPrime[0] = isPrime[1] = false;
    for (int i = 2; i <= n; i++) {
        if (isPrime[i]) {
            primes.push_back(i);
        }
        for (int j = 0; j < primes.size() && i * primes[j] <= n; j++) {
            isPrime[i * primes[j]] = false;
            if (i % primes[j] == 0) break;
        }
    }
}

这里我故意用vector<bool>演示，但必须提醒一句：vector<bool>是一个特化的位压缩版本，它对bool元素做了空间优化，但元素访问返回的不是真正的bool引用，在某些环境下配合复杂操作会出幺蛾子。如果你不想被这种细节坑，直接用vector<char>或者bool isPrime[10000005]即可，内存稍大，但行为更直观。

还有一个常见错误是内层循环判断条件写成j < primes.size()但漏掉i * primes[j] <= n这个范围检查。如果不加，i * primes[j]会越界，轻则数组越界崩溃，重则悄悄写坏内存、在OJ上表现为莫名WA。稳妥做法是每次循环前先判断乘积是否超范围，乘积本身要用long long再观察一下，防止i * primes[j]在int范围内溢出。

5. 常见应用场景与题目变形

学会了欧拉筛，很多所谓“数论基础题”其实就已经捅破窗户纸了。这一节我梳理一下题目里最常见的几种应用，你会发现大部分看似花哨的题，底层都是这套东西。

5.1 题目里最常见的三类素数题

第一类是“判断类”，比如给你一个数问它是不是素数，直接用第2节的单个判断函数解决，但要注意数据范围。如果给了多个测试用例，且上限固定，那就先欧拉筛预处理，然后每次O(1)查isPrime数组。

第二类是“计数类”，比如求[2, n]内有多少个素数。这类题通常要求线性筛后，再求一遍素数数量的前缀和。注意不要在统计时每次从1扫到n，而是维护一个cnt数组，筛完素数后cnt[i] = cnt[i-1] + (isPrime[i] ? 1 : 0)，这样区间查询[L, R]直接cnt[R] - cnt[L-1]，O(1)出结果。

第三类是“区间类”，比如输出某个区间内的所有素数，或者找相邻素数对。做法完全一样：欧拉筛预处理到上限，然后遍历区间，检查isPrime数组即可。

搜索热词里的“1139. 孪生素数”“1403:素数对”都属于第三类，接下来我展开写一下这类题的核心解法。

5.2 预处理后O(1)判断：孪生素数与素数对的写法

孪生素数指相差为2的一对素数，比如(3,5)、(5,7)、(11,13)。处理思路非常直接：欧拉筛预处理后，遍历每个p，如果p和p+2都是素数，就找到了一对。

cpp复制#include <bits/stdc++.h>
using namespace std;

const int MAXN = 10000000;
vector<int> primes;
vector<char> isPrime(MAXN + 1, true);

void linearSieve(int n) {
    isPrime[0] = isPrime[1] = false;
    for (int i = 2; i <= n; i++) {
        if (isPrime[i]) primes.push_back(i);
        for (int j = 0; j < (int)primes.size() && i * primes[j] <= n; j++) {
            isPrime[i * primes[j]] = false;
            if (i % primes[j] == 0) break;
        }
    }
}

int main() {
    int n;
    cin >> n;
    linearSieve(n);
    int cnt = 0;
    for (int p = 2; p + 2 <= n; p++) {
        if (isPrime[p] && isPrime[p + 2]) {
            cnt++;
            // 如果需要输出具体素数对，可以在这里 cout << p << " " << p + 2 << "\n";
        }
    }
    cout << cnt << "\n";
    return 0;
}

“1403:素数对”这类题描述可能会稍微变一下，比如要求输出满足“两个数都是素数且差为2”的所有数对，或者要求“相邻素数差为2”。解题模板还是上面这套，最多改一下输出格式。你需要警惕的坑是输出顺序、空格格式、以及是否需要特判p=2的情况。在素数对问题里，(2,3)虽然相差1，不属于素数对，不用考虑。

5.3 区间筛：筛出[L,R]里的素数

有些题不给你一个从1开始的完整区间，而是直接给[L, R]，其中R可以达到10^12，但R-L很小，比如不超过10^6。这时候你把R范围内的欧拉筛跑一遍，内存和时间都炸了。

正确的做法是“区间筛”：先用欧拉筛筛出[2, sqrt(R)]范围内的素数（这个范围通常很小，比如sqrt(10^12)=10^6，内存完全扛得住），然后用这些素数去标记[L, R]区间内的合数。标记方式比直接开[1,R]的数组省太多。

核心代码逻辑如下：

cpp复制vector<char> segIsPrime(R - L + 1, true);
for (int p : primes) {
    if (1LL * p * p > R) break;
    long long start = max(1LL * p * p, (L + p - 1) / p * 1LL * p);
    for (long long j = start; j <= R; j += p) {
        segIsPrime[j - L] = false;
    }
}
if (L == 1) segIsPrime[0] = false; // 1不是素数

这里start的计算是一个很经典的细节。(L + p - 1) / p * p是大于等于L且能被p整除的第一个数，p*p是p的最小合法标记起点，两者取较大者。如果漏掉这个处理，直接从L往下找倍数，可能会标记到L之前的位置，导致数组下标负数崩溃。我在实际刷题时见过不少人在这一步翻车。

区间筛在OJ里出现的频率不低，尤其是涉及大范围素数的题目，属于典型的高级应用。学会它之后，很多看似数据量很大的素数题就不虚了。

5.4 质因数分解和积性函数扩展

欧拉筛另一个高频用途是配合唯一分解定理做质因数分解。比如给一个数x，求它的标准分解式。先用欧拉筛筛出不超过sqrt(x)的素数，然后依次尝试相除：

cpp复制vector<pair<int,int>> factorize(int x) {
    vector<pair<int,int>> res;
    for (int p : primes) {
        if (1LL * p * p > x) break;
        if (x % p == 0) {
            int cnt = 0;
            while (x % p == 0) {
                x /= p;
                cnt++;
            }
            res.push_back({p, cnt});
        }
    }
    if (x > 1) res.push_back({x, 1});
    return res;
}

这里有个容易忽略的点：循环结束后，如果x还大于1，说明它本身一定是一个大于sqrt(原始x)的素数，要单独加入结果。很多新手忘了这一步，导致分解结果缺项，最常见的就是x=10时，循环结束后x=5，没有这一步结果里就没有5。

再往深走，欧拉筛真正的价值在于“积性函数筛”。欧拉函数φ、莫比乌斯函数μ这些积性函数，都可以在线性筛的过程中顺便求出来，用到的核心工具还是“最小质因子”。比如筛欧拉函数时，当i % primes[j] == 0时，φ(i * primes[j]) = φ(i) * primes[j]；否则φ(i * primes[j]) = φ(i) * (primes[j] - 1)。这些公式看起来复杂，但只要理解最小质因子的标记逻辑，就能直接套用。这也是为什么很多数论进阶题目的前置技能是“先背熟欧拉筛模板”。

如果看到题目名称里带“lucas的数论”这类进阶内容，也不用慌。那通常意味着除了素数之外，还会结合Lucas定理、组合数取模等知识，但前置基础依然是素数筛和唯一分解。先把欧拉筛这一步打牢，后续扩展才有根基。

6. 常见问题与提交报错排查实录

写了这么多年算法题，身边同学在素数题上翻车的频率远超想象。这里我把最典型的几个问题整理成一份速查表，每个都是真实踩过或看人踩过的坑。

6.1 环境差异与STL选型

先聊一下编码层面的常见问题。很多人用C++写筛法时纠结用vector<bool>还是bool[]。vector<bool>确实省内存，但它不是标准容器，专门做了位压缩，operator[]返回的是代理对象，不是真正的bool&。要遍历它，比如写for (bool x : isPrime)，某些编译器行为是符合预期的，但一旦涉及修改引用，就可能出问题。

我的建议是：在竞赛环境下直接用vector<char>或普通bool数组。一个bool数组占1字节，n=10^7时也就10MB，完全在内存限制内；vector<char>占用的空间同样可控。如果内存真的很紧张（n=10^8级别），再考虑vector<bool>或bitset。另外，bitset虽然空间更优，但没法动态调整大小，而且操作起来速度不一定比数组快，实际用到的场景不算多。

6.2 几个高发坑点速查表

其中“每次查询都重新筛一遍”这个坑在OJ上尤其隐蔽。比如题目是T组测试，每组给一个n，求n以内素数个数。很多人把筛法写在每组数据内部，T=10、n=10^7时就跑了十遍筛法，直接超时。正确思路是读入所有测试数据，取最大值maxN，只筛一次到maxN，然后每组查询O(1)回答。这就是“离线预处理”的典型用法。

6.3 调试建议

调试筛法类的题目，我有个习惯：先用一个很小的n，比如n=30，手动写出期望的素数表，然后打印自己代码的筛法结果做对比。如果结果一致，基本可以确定核心逻辑没问题，后面出错大概率是边界或输出格式。

另外可以写一个极简的暴力isPrime函数，作为对拍器。筛法算出来的素数表和暴力判断的素数表逐个对比，发现不一致就定位到具体的i，然后再看那个合数是被谁标记的，很快就能找到问题。这个方法在排查欧拉筛“重复标记”“漏标记”时格外好用。

还有一个提醒：每次修改代码后，先跑一次边界测试，比如n=2、n=3、n=10、n=1000000，再提交。不要只测用例数据，边界数据往往才是隐藏炸弹。我做这类题时，n=2和n=3这两个最小边界一定单独测一遍，因为素数表空、循环不执行这些极端情况，最容易在无意识中出错。

最后分享一个我个人的操作习惯。涉及任何“多次判断素数”的题目，我不管题目表面上问什么，先把欧拉筛模板写到最前面，预处理到题目给定的最大上限。虽然前期多写了十几行代码，但后面所有素数判断都是O(1)，心里踏实。特别是到了比赛后半段，人的思维容易疲劳，手头有一个调试过无数遍的稳定模板，能省下大量不必要的心力。如果你刚开始练数论，建议把这套模板背熟，拿“1139. 孪生素数”“1403:素数对”这类题反复练手，直到能在五分钟内不假思索地写出来，再往后学区间筛、积性函数筛，你会发现自己比别人快出一大截。