素数筛法：埃氏筛法与线性筛法

最新推荐文章于 2025-02-10 08:07:05 发布

墨染心弦

最新推荐文章于 2025-02-10 08:07:05 发布

阅读量1.3k

点赞数 21

分类专栏：算法学习文章标签： c++ 算法

本文链接：https://blog.csdn.net/2301_79385139/article/details/144009468

版权

算法学习专栏收录该内容

1 篇文章

订阅专栏

素数筛法

埃氏筛法

Eratosthenes筛法 (埃拉托斯特尼筛法，简称埃氏筛法)。
时间复杂度是 $O(n\log\log n)$ 。

如果我们从小到大考虑每个数，然后同时把当前这个数的所有（比自己大的）倍数记为合数，那么运行结束的时候没有被标记的数就是素数了。

例如：
考虑 2 时, 我们把 4, 6, 8, 10, 12, 14, 16, 18 … 均标记为合数。

考虑 3 时, 我们把 6, 9, 12, 15, 18, 21, 24, 27 … 均标记为合数。

考虑 4 时, 我们把 8, 12, 16, 20, 24, 28, 32, 36 … 均标记为合数。

考虑 5 时, 我们把 10, 15, 20, 25, 30, 35, 40, 45 … 均标记为合数。

显然这里对 4 的倍数的筛选是没有必要的，因为 4 是 2 的倍数，在筛选 2 的倍数时肯定会一并把 4 的倍数也筛掉。
同理我们也没有必要筛 6 的倍数，8 的倍数，9 的倍数，我们只需要根据素数的倍数筛选就行。
即我们只筛选 $\cdots$ 的倍数即可。

而对于一个不超过 $n$ 的合数来说，至少有两个质因子。
所以至少有一个质因子不超过 $\sqrt{n}$ ,否则两个大于 $\sqrt{n}$ 的质因子相乘肯定大于 $n$ 。

如果要找到直到 n 为止的所有素数，仅对不超过 $\sqrt{n}$ 的素数进行筛选就足够了。

vector<int> prime;
bool is_prime[N];

void Eratosthenes(int n) {
    // 初始化所有数的标记
    is_prime[0] = is_prime[1] = false;// 0和1不是素数
    for (int i = 2; i <= n; ++i) {
        is_prime[i] = true;
    }

    // i * i <= n 说明 i <= sqrt(n)
    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;
            }
    }

    for (int i = 2; i <= n; ++i) {
        if (is_prime[i]) {
            prime.push_back(i);
        }
    }
}

线性筛法

线性筛法也称为 Euler 筛法 (欧拉筛法)，是埃氏算法的改进版本。

埃氏筛法仍有优化空间，它会将一个合数重复多次标记。
如果能让每个合数都只被标记一次，那么时间复杂度就可以降到 $O (n)$ 了。

例如：
6 会在筛 2 和 3 的倍数时重复出现。（ $\times 3$ ）
12 会在筛 2 和 3 的倍数时重复出现。 ( $2^2 \times 3$ )
30 会在筛 2 、3 、5 的倍数时重复出现。( $\times 3 \times 5$ )

也就是说假设一个数 ${p_1}^{n_1}{p_2}^{n_2}\cdots{p_k}^{n_k}$
那么他就会在筛 $p_1, p_2, \cdots, p_k$ 的倍数时重复出现 k 次

我们希望每个合数仅被筛选一次，且 每个合数只被它的最小质因子筛去，不重复进行筛选。

而对于每一个合数 $x$ , 设 $x$ 的最小质因子为 $p$ , 则 $x$ 可以写成 $x = k * p$ 的形式.

一个自然的想法是我们此时枚举最小质因子 $p$ 的值，即筛去最小质因子为 $\cdots$ 的数。

但是此时不能像普通的埃氏算法那样直接筛去 $p$ 的倍数，因为 $p$ 的倍数的最小质因子不一定是 $p$ 。

例如对于 3 而言， 3 的倍数中 6，12，18 等数的最小质因子都是 2, 只有 9, 15, 21 等的最小质因子为 3 。

实际上这里筛去某个素数 $p$ 的 $k$ 倍时，必须保证 $k$ 的任意一个质因子均不小于 $p$ ，否则 $k * p$ 的最小质因子必定不是 $p$ 。

以 $p = 5$ 为例， $p$ 的倍数有 $\cdots$ ， $k$ 的质因子中不能包含 2 和 3, 只能包含 $\cdots$
所以我们应该筛去的是 $\cdots$ , 至于 10 我们在筛 2 的倍数时候筛去， 15 在筛 3 的倍数时筛去。

但是我们没法直接知道大于 $p$ 的素数(对于上面来说是 $5, 7, 11, 13$ 等)，这正是我们需要求的问题。

因此我们重新考虑枚举最小质因子的倍数 k 的值。

我们先来看一些具体的例子
$2\quad(k = 2, p = 2)\\ 6 = 3 * 2\quad(k = 3, p = 2)\\ 8 = 4 * 2\quad(k = 4, p = 2)\\ 9 = 3 * 3\quad(k = 3, p = 3)\\ 10 = 5 * 2\quad(k = 5, p = 2)\\ 12 = 6 * 2\quad(k = 6, p = 2)\\ 15 = 5 * 3\quad(k = 5, p = 3)\\ 20 = 10 * 2\quad(k = 10, p = 2)\\ 30 = 15 * 2\quad(k = 15, p = 2)\\ 35 = 7 * 5\quad(k = 7, p = 5)\\ 46 = 23 * 2\quad(k = 23, p = 2)\\$

初步来看 $k$ 需要枚举 2 到 n 内的所有数，而由前面知 $k$ 的任意一个质因子均不小于 $p$ , 即至少 $k\ge p$ 。
且对于一个固定的 $k$ 来说 $p$ 不能大于 $k$ 的最小质因子 ，否则 $k * p$ 的最小质因子必定不是 $p$ 。

对于每一个 $k$ ， $p$ 从 2 不断枚举, 直到 $k * p > n$ 或者 $k\% p == 0$ 。
前者说明要筛的数超过了 $n$ 的范围，我们不再关心。
后者说明此时的 $p$ 恰好是 $k$ 的最小质因子，因为 $p$ 是从2开始不断增大的，第一次能整除 $k$ 的就是 $k$ 的最小质因子。
此时我们不用再枚举 $p + 1$ 了，因为 $p + 1$ 肯定大于 $k$ 的最小质因子 $p$ 。

vector<int> prime;
bool is_prime[N];

void Euler(int n) {
    // 初始化所有数的标记
    is_prime[0] = is_prime[1] = false; // 0和1不是素数
    for (int i = 2; i <= n; ++i) {
        is_prime[i] = true;
    }

    for (int i = 2; i <= n; ++i) {
        if (is_prime[i]) {
            prime.push_back(i);
        }
        for (int j = 0 ; j < prime.size(); ++j) {
            int x = i * prime[j]; // 需要筛去的数
            if (x > n) break;
            is_prime[x] = false;
            if (i % prime[j] == 0) break;
        }
    }

    for (int i = 2; i <= n; ++i) {
        if (is_prime[i]) {
            prime.push_back(i);
        }
    }
}