数论：筛法

一个证明

在讲筛法前，先证明一个东西：

$$对于一个合数x，一定存在一个质数p\le \sqrt{x}且p|x。$$

---

• 先把结论考虑简单一点：合数$x$一定存在一个小于等于$\sqrt{x}$的因数。

  显然一个合数$x$可以被一对非$1$非$x$的整数$p,q$表示为 $x=pq$，

  则其中至少有一个整数小于$x$，

  因为若$p,q>\sqrt{x}$，那么$pq>x$。

---

• 再进一步考虑这个结论：合数$x$一定存在一个小于等于$\sqrt{x}$的质因数。

  我们先假设每个合数不存在非$1$质因子，

  对于合数$x$，它一定有一个的小于等于$\sqrt{x}$的非$1$因数$p$，

  而已经假设了每个合数不存在质因子，所以$p$为合数，

  那么对于合数$p$, 它一定又有一个小于等于$\sqrt{p}$的非$1$合数因子$p_1$,

  则$p_1$也为$a$的因子，

  同上可得：$p_1$也一定有一个小于等于$\sqrt{p_1}$的非$1$合数因子$p_2$，

  $p_2$也为$a$的因子，
  …
  如此循环往复可以做到$a$的一个因子$p_n\le \sqrt{\sqrt{\sqrt{\sqrt{...}}}}$，
  显然不等号右边的式子可以轻而易举地做到【大于 1 且 小于 2】，

  由于$(1,2)$区间内不存在合数，所以假设不成立。

筛法

筛法是对质数和合数进行分类的工具。
假如将所有整数放进一个筛子，那么这个筛子会筛掉合数，留下质数。

一个正确的筛法要同时满足两点：

1. 留下的都是质数
2. 筛去的都是合数和$01$

本章介绍三种筛法及其优化和正确性证明

---

普通筛

普通筛是针对某一个单独的整数判断它是否为质数。

先上代码：

bool is_prime(int x) {
    if (x < 2) return false;  
    for (int i = 2; i < x; ++i)  
        if (x % i == 0) 
            return false; 
    return true;  
}

很显然，$0$和$1$都不是质数，这就是第一个判断所做的。
在判断一个数是否是质数时，我们只需要判断它是否有除平凡约数（就是$1$和它本身）外的其他约数即可，这就是循环所做的。
这样的时间复杂度是$O(n)$。

优化

显然对于一个合数$x$，一定存在一个质数$p\le \sqrt{x}$且 $p|x$。
那么我可以将枚举上限设为$\sqrt{x}$,那样一样可以找到$x$的一个因数。
代码如下：

bool is_prime(int x) {
    if (x < 2) return false;  
    for (int i = 2; i * i <= x; ++i)  // 等价于 i <= sqrt(x)
        if (x % i == 0) 
            return false; 
    return true;
}

这样的时间复杂度是$O(\sqrt{n})$。

---

埃氏筛

用于确定$[1,n]$内的质数。

原理很简单，就是质数的倍数即为合数。

那如何实现呢？或者更具体说，如何“先”找到质数？

1. 先给每个数【都】打上质数标记$isPrime[i]$，表示数$i$是质数。
2. 外层循环遇到一个质数。
3. 进入内层循环把【这个质数的倍数】（就是含有该质因数的合数）的“质数标记”删去。
4. 当外层循环完毕时，剩下【有“质数标记”的】就是质数。

先上代码：

int n;

int prime[maxn], cnt;  // 用来存质数

bitset<maxn> isPrime;  // 质数标记：1 表是质数，0 表不是质数
// 用 bitset 更省空间
// 相当于：bool isPrime[maxn]

void Eratosthenes() {
    isPrime.set();   
    // 相当于：memset(isPrime, true, sizeof(isPrime))
    
    isPrime[0] = isPrime[1] = false;  // 0 和 1 均不为质数
    
    // 实现 1
    for (int i = 2; i <= n; ++i) {   
        if (isPrime[i]) {
            prime[++cnt] = i;
            for (int j = i * 2; j <= n; j += i)
                isPrime[j] = false;
        }
    }
    
    // 实现 2
    // for (int i = 2; i <= n; ++i) {
    //     if (isPrime[i]) prime[++cnt] = i;
    //     for (int j = 1; j <= cnt && i * prime[j] <= n; ++j)
    //         isPrime[i * prime[j]] = false;
    // }
    // 实现 2 主要是为了方便下来讲解在此基础上实现的线性筛
}

正确性

此做法的正确性来源于每个合数都至少有一个质因数（已经证明过了），而每个质数的因子都只有$1$和它自己。

想一想当前外层循环运行到$i=x$时：
如果它被筛去了，由于循环从$2$开始，所以它不可能被$1$筛去，那么说明筛去它的是一个大于$1$且小于它自己的数，换而言之它存在除平凡因数外的因数，它是个合数；
如果它没被筛去，那么说明它不存在除平凡因数外的因数，它是个质数。
这就证明了埃氏筛的正确性：

1. 留下的都是质数
2. 筛去的都是合数和$01$

根据证明我们可以明白一件事：$x$是质数还是合数在外层循环运行到$i=x$前就可以得到判断；当外层循环运行到$i=x$时，$[2,x]$间所有数是质是合都可得到判断。

优化

注：以下优化均以实现1为基础

优化1

先证明一个东西：

$$[1,i]以内的质数可以把[1,i^2]内的合数全部筛掉。$$

很显然当外层循环到$i$时，$[1,i]$内的所有质数和合数均已确定。
现在考虑在$(i,i^2]$的一个合数$x$，
根据每个合数至少存在一个质因子，且小于等于$\sqrt{这个合数}$，
我们可知$x$有个质因子小于等于 $\sqrt{x}$，即在 $[1,i]$区间内，
由于外层循环已经确定了$[1,i]$的所有质数，
因此我们可以再通过内层循环将$(i,i\ast i]$内的合数筛去。

所以外层循环上限可以改为：

for(int i = 2; i * i <= n; ++i)

延续思路，当$i$为质数进入内层循环时，由于$[1,i-1]$的质数已经把$[1,(i-1{)}^2]$的合数筛去了，所以我们$j$ 要找到一个【大于且离$(i-1{)}^2$最近的】$i$的倍数作为循环起点，显然起点为$i(i-1)$，但它又很明显是$i-1$的倍数，因此当$i-1\ne 1$即$i\ne 2$时它一定也被筛去了，所以循环起点定为$i^2$。

for (int j = i * i; j <= n; j += i)

注：当$i=2$时，$i(i-1)=2$，此时若再将其作为内层循环起点就会把$isPrime[2]$标记为$false$，显然错误。

优化2

显然所有偶数均为合数，所以只需判断一个奇数是否为质数。
结合优化1给出如下代码：

void Eratosthenes() {
    isPrime.set();   
    
    isPrime[0] = isPrime[1] = false;
    for (int i = 4; i <= n; i += 2)
        isPrime[i] = false;  // 严谨一点把的非 2 偶数 isPrime 也删除一下
    
    for (int i = 3; i * i <= n; i += 2) {   
        if (isPrime[i]) {
            for (int j = i * i; j <= n; j += i)
                isPrime[j] = false;
        }
    }
    
    prime[++cnt] = 2;
    for (int i = 3; i <= n; i += 2)
        if (isPrime[i])
            prime[++cnt] = i;
}

时间复杂度为$O(nln(ln(n)))$，具体证明。
注：优化只能省去一些不必要的操作，并不能改变复杂度。

---

线性筛（欧拉筛）

同样用于确定$[1,n]$内的质数。

是在埃氏筛实现2的基础上实现的。

先给代码：

void Euler() {
    isPrime.set();
    isPrime[0] = isPrime[1] = false;
    for (int i = 2; i <= n; ++i) {
        if (isPrime[i]) prime[++cnt] = i;
        for (int j = 1; j <= cnt && i * prime[j] <= n; ++j) {
            isPrime[i * prime[j]] = false;
            if (i % prime[j] == 0) break;  // 关键
        }
    }
}

看来线性复杂度的秘诀就在这个关键判断语句上。
下来给出证明：

显然埃氏筛会重复的筛去相同的质数,
如: 考虑$2$时，它会筛去$6，12，\mathrm{18...}$
考虑$3$时，它还会筛去$6，12，\mathrm{18...}$
这就导致了时间复杂度会乘以$ln(ln(n))$.

那为什么这行判断会省去多余的筛次,
如果$prime[j]|i$,
设 $m=i/prime[j]$，即$i=x\ast prime[j]$，
那么$i\ast prime[j+k]=x\ast prime[j]\ast prime[j+k]$，
（$1\le k\le n-j$，$prime[j+k]$其实指的就是$prime$数组中剩下的质数），
也就是说$i\ast prime[j+k]$会被$prime[j]$筛去，还会被$prime[j+k]$筛去，既然它已经被筛了，那就不必麻烦$prime[j+k]$再把它筛一遍，所以直接$break$。

时间复杂度正如它的名字：$O(n)$。