质数筛三种算法详解：从埃氏筛法到线性筛法与欧拉筛法

先上总结：

1. 埃拉托色尼筛法：简单易懂，适合初学者学习。
2. 线性筛法：效率更高，时间复杂度 $O(n)$。
3. 欧拉筛法：与线性筛法类似，核心思想是确保每个合数只被其最小质因数筛除一次，避免重复操作。

---

1 数学基础

质数是大于1的自然数，且只有两个正因数：1和它本身。例如，2、3、5、7是质数，而4、6、8不是质数。

• 如果一个数$n$不是质数，则它可以被分解为两个较小的正整数的乘积，即$n=a\times b$，其中$1<a,b<n$。
• 如果$n$不是质数，那么它至少有一个因数小于或等于$\sqrt{n}$。这是因为如果$n=a\times b$，且$a>\sqrt{n}$和$b>\sqrt{n}$，则$a\times b>n$，这与$n=a\times b$矛盾。

---

2 埃拉托色尼筛法（Eratosthenes）

2.1 基本思想

埃拉托色尼筛法是一种古老的算法，用于找到不大于给定整数$n$的所有质数。其核心思想是：

• 初始化一个布尔数组is_prime，长度为$n+1$，并将所有元素初始化为true。
• 遍历数组中的每个数$i$（从2开始），如果$i$是质数，则将其所有的倍数标记为非质数。
• 最终，数组中仍为true的索引即为质数。

2.2 数学相关

根据质数的性质，如果$i$是质数，则它的所有倍数$2i,3i,\dots$都不是质数。因此，我们只需要从$i^2$开始标记$i$的倍数即可（因为小于$i^2$的倍数已经被更小的质数标记过）。

• 外层循环遍历所有可能的质数$i$。
• 内层循环标记$i$的倍数。
• 总的时间复杂度为$O(n\log \log n)$，这是由于每个数最多只会被其最小质因数标记一次。

假设我们要筛选出$[2,n]$内的所有质数：对于每个质数$p$，我们需要标记$p^2,p^3,\dots ,kp$（直到$kp\le n$）。每个合数只会被其最小质因数标记一次，因此总的操作次数为：
$$\sum _{p\text{ is prime}}\frac{n}{p}$$
利用调和级数的性质，可以证明总的操作次数为$O(n\log \log n)$。

---

2.3 C++

#include <iostream>
#include <vector>
using namespace std;

vector<int> sieveOfEratosthenes(int n) {
    vector<bool> is_prime(n + 1, true);
    is_prime[0] = is_prime[1] = false;

    for (int i = 2; i * i <= n; ++i) {
        if (is_prime[i]) {
            for (int j = i * i; j <= n; j += i) {
                is_prime[j] = false;
            }
        }
    }

    vector<int> primes;
    for (int i = 2; i <= n; ++i) {
        if (is_prime[i]) {
            primes.push_back(i);
        }
    }
    return primes;
}

int main() {
    int n;
    cin >> n;
    vector<int> primes = sieveOfEratosthenes(n);
    for (int prime : primes) {
        cout << prime << " ";
    }
    return 0;
}

---

3 线性筛法（Linear Sieve）

3.1 基本思想

线性筛法是一种优化的质数筛算法，其时间复杂度为$O(n)$。其核心思想是：

• 每个合数只被其最小质因数筛除一次。
• 使用一个数组primes来存储已经找到的质数。
• 遍历每个数$i$，将其与已知质数的乘积标记为合数。

3.2 数学相关

对于每个数$i$，我们尝试将其与已知质数的乘积标记为合数。为了避免重复标记，当$i\%p==0$时停止标记，因为此时$i\times p$已经被更小的质数标记过。

由于每个合数只被其最小质因数筛除一次，因此总的操作次数等于所有合数的数量加上质数的数量，即$n$。最终的时间复杂度为$O(n)$。

假设我们要筛选出$[2,n]$内的所有质数：

• 对于每个数 $i$，我们遍历质数列表primes中的所有质数$p$，并将 $i\times p$ 标记为合数。
• 当 $i\%p==0$ 时，停止标记。这意味着每个合数只会被其最小质因数筛除一次。
• 因此，总的标记操作次数为$n$，再加上生成质数列表的操作次数，最终的时间复杂度为$O(n)$。

---

3.3 C++

#include <iostream>
#include <vector>
using namespace std;

vector<int> linearSieve(int n) {
    vector<int> primes;
    vector<bool> is_prime(n + 1, true);
    is_prime[0] = is_prime[1] = false;

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

int main() {
    int n;
    cin >> n;
    vector<int> primes = linearSieve(n);
    for (int prime : primes) {
        cout << prime << " ";
    }
    return 0;
}

---

4 欧拉筛法（Euler Sieve）

4.1 基本思想

欧拉筛法与线性筛法类似，也是一种高效的质数筛算法，其时间复杂度为$O(n)$。它的核心思想是通过确保每个合数只被其最小质因数筛除一次，避免了重复操作。

4.2 数学相关

假设我们要筛选出$[2,n]$内的所有质数。对于每个数$i$，我们尝试将其与已知质数的乘积标记为合数。为了避免重复标记，当$i\%p==0$时停止标记，因为此时$i\times p$的最小质因数已经是$p$。

欧拉筛法的核心在于每个合数只会被其最小质因数筛除一次。因此，总的操作次数等于所有合数的数量加上质数的数量，即$n$。最终的时间复杂度为$O(n)$。

假设我们要筛选出$[2,n]$内的所有质数：

• 对于每个数$i$，我们遍历质数列表primes中的所有质数$p$，并将$i\times p$标记为合数。
• 当$i\%p==0$时，停止标记。这意味着每个合数只会被其最小质因数筛除一次。
• 因此，总的标记操作次数为$n$，再加上生成质数列表的操作次数，最终的时间复杂度为$O(n)$。

---

4.3 C++

#include <iostream>
#include <vector>
using namespace std;

vector<int> eulerSieve(int n) {
    vector<bool> is_prime(n + 1, true);
    vector<int> primes;
    is_prime[0] = is_prime[1] = false;

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

int main() {
    int n;
    cin >> n;
    vector<int> primes = eulerSieve(n);
    for (int prime : primes) {
        cout << prime << " ";
    }
    return 0;
}

---