CSP-J复赛复习专栏 - 05素数筛算法

素数筛算法

1.1 试除法

#include <iostream>
using namespace std;

// 判断一个数是否为素数的函数
bool isPrime(int n) {
    if (n <= 1) return false;  // 小于等于1的数都不是素数
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) {  // 如果n能被i整除，说明n不是素数
            return false;
        }
    }
    return true;  // 如果没有发现因子，n是素数
}

int main() {
    int n;
    cout << "请输入一个整数: ";
    cin >> n;

    if (isPrime(n)) {
        cout << n << " 是素数。" << endl;
    } else {
        cout << n << " 不是素数。" << endl;
    }

    return 0;
}

1.2 埃筛

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

// 使用埃拉托色尼筛法生成所有小于等于n的素数
vector<int> sieveOfEratosthenes(int n) {
    vector<bool> isPrime(n + 1, true);  // 初始化一个布尔数组，将所有元素标记为true
    isPrime[0] = isPrime[1] = false;    // 0和1不是素数，标记为false

    for (int i = 2; i * i <= n; i++) {
        if (isPrime[i]) {
            // 将i的所有倍数标记为false
            for (int j = i * i; j <= n; j += i) {
                isPrime[j] = false;
            }
        }
    }

    // 收集所有标记为true的素数
    vector<int> primes;
    for (int i = 2; i <= n; i++) {
        if (isPrime[i]) {
            primes.push_back(i);
        }
    }

    return primes;
}

int main() {
    int n;
    cout << "请输入一个整数n，生成所有小于等于n的素数: ";
    cin >> n;

    vector<int> primes = sieveOfEratosthenes(n);

    cout << "小于等于 " << n << " 的素数有: ";
    for (int prime : primes) {
        cout << prime << " ";
    }
    cout << endl;

    return 0;
}

代码解释如下：

首先，初始化一个布尔数组，假定所有数都为素数。数组的大小为 n + 1，初始值为 true。我们将 0 和 1 设为 false，因为它们不是素数。

接着，从 2 开始遍历，如果 i 是素数（isPrime[i] 为 true），则将 i 的所有倍数标记为合数。内层循环从 i * i 开始，因为小于 i * i 的倍数已经被之前的素数筛选掉了。

然后，我们遍历布尔数组，将所有标记为 true 的数收集到素数列表中。

最后，通过 sieveOfEratosthenes 函数生成素数列表，并输出这些素数。例如，输入 n = 30，输出 小于等于 30 的素数有: 2 3 5 7 11 13 17 19 23 29。

埃拉托色尼筛法的时间复杂度为 O(n log log n)，在计算素数时非常高效。

1.3 线性筛

线性筛法是一种改进的素数筛选算法，它的时间复杂度为 (O(n))。与埃拉托色尼筛法相比，线性筛法不会重复标记同一个数，从而使筛选过程更加高效。

下面是线性筛法的C++代码示例，用于生成某个范围内的所有素数：

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

// 使用线性筛法生成所有小于等于n的素数
vector<int> linearSieve(int n) {
    vector<int> primes;               // 存储所有的素数
    vector<bool> isPrime(n + 1, true); // 标记素数的布尔数组

    for (int i = 2; i <= n; i++) {
        if (isPrime[i]) {
            primes.push_back(i);      // i 是素数，将其加入素数列表
        }
        for (int j = 0; j < primes.size() && i * primes[j] <= n; j++) {
            isPrime[i * primes[j]] = false; // 标记 i * primes[j] 为合数
            if (i % primes[j] == 0) {
                break; // 如果 i 是 primes[j] 的倍数，停止进一步的标记
            }
        }
    }

    return primes;
}

int main() {
    int n;
    cout << "请输入一个整数n，生成所有小于等于n的素数: ";
    cin >> n;

    vector<int> primes = linearSieve(n);

    cout << "小于等于 " << n << " 的素数有: ";
    for (int prime : primes) {
        cout << prime << " ";
    }
    cout << endl;

    return 0;
}

代码解释如下：

首先，初始化一个布尔数组 isPrime，用于标记哪些数是素数。初始化时，所有数都假定为素数（标记为 true）。同时，准备一个整数向量 primes 来存储所有找到的素数。

然后，我们从 2 开始遍历每个整数 i。如果 i 是素数（即 isPrime[i] 为 true），将 i 加入到 primes 列表中。

对于每个 i，我们使用当前的素数列表 primes，标记 i 与每个素数 primes[j] 的乘积为合数。如果 i 是 primes[j] 的倍数（即 i % primes[j] == 0），那么我们可以停止标记，因为 i * primes[j] 是 primes[j] 的倍数，将来会由其他较小的素数标记。

最后，函数返回所有找到的素数，并在 main 函数中输出这些素数。

例如，输入 n = 30，输出 小于等于 30 的素数有: 2 3 5 7 11 13 17 19 23 29。

线性筛法在处理大范围的素数时非常高效，因为它只标记每个合数一次，时间复杂度为 (O(n))。