acwing 868. 筛质数

给定一个正整数 n，请你求出 1∼n 中质数的个数。

输入格式
共一行，包含整数 n。

输出格式
共一行，包含一个整数，表示 1∼n 中质数的个数。

数据范围
1≤n≤10⁶

输入样例：
8
输出样例：
4

方法1： 朴素版本筛质数：暴力枚举
直接通过枚举1~n 的质数，然后标记一个数的倍数即可
时间复杂度： O(nlogn)

void get_primes(int n)
{
    for(int i = 2; i <= n; i ++)
    {
        if(!st[i]) primes[cnt ++] = i;  // 保存质数
        for(int j = i; j <= n; j += i)  // 删除质数的倍数
            st[j] = true;
    }
}

方法2：埃氏筛选法： 用质数去筛选合数，但是不能保证每个数筛选了几次
时间复杂度： O(nloglogn)

void get_primes(int n)
{
    for(int i = 2; i <= n; i ++)
    {
        // 只需要筛选质数的倍数就行了
        if(!st[i])
        {
            primes[cnt ++] = i;   // 保存质数
            for(int j = i; j <= n; j += i) //可以用质数就把所有的合数都筛掉；
                st[j] = true;
        }
    }
}

方法3： 线性筛选法：保证了每个合数被最小质因子筛选出来的，只筛选了一次，所以是线性的
也叫欧拉筛选法

埃氏筛存在一个缺陷，即对于一个合数，可能会被筛多次，例如 30=2×15=5×6…30=2×15=5×6…，我们改用其最小质因子去筛掉这个合数，就可以保证他只会被筛一次。

我们从小到大枚举所有质因子 primes[j]。

1、当出现 i % primes[j] == 0 时，primes[j] 一定是 i 的最小质因子，因此也一定是 primes[j] * i 的最小质因子。

2、当出现 i % primes[j] != 0 时，说明我们还尚未枚举到 i 的任何一个质因子，也就表示 primes[j] 小于 i 的任何一个质因子，这时 primes[j] 就一定是 primes[j] * i 的最小质因子。

可以发现无论如何，primes[j] 都一定是 primes[j] * i 的最小质因子，并且由于所要筛的质数在 2∼n 之间，因此合数最大为 n，故 primes[j] * i 只需枚举到 n 即可，但由于 primes[j] * i 可能会溢出整数范围，故改成 primes[j] <= n / i 的形式。

时间复杂度： O(n)

void get_primes3(int n)
{
    for(int i = 2; i <= n; i ++)
    {
        // 如果不是质数， 加入进去
        if(!st[i]) primes[cnt ++] = i;  // 保存质数
        // 这个筛法：是从小到大枚举所有的质数
        for(int j = 0; primes[j] <= n / i; j ++)
        {
            // ...
            st[primes[j] * i] = true;
            if(i % primes[j] == 0) break;   // primes[j] 一定是i 的最小质因子
        }
    }
}

完整代码如下：

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1e6 + 10;
bool st[N];
int primes[N], cnt;

// 朴素版本筛质数
void get_primes(int n)
{
    for(int i = 2; i <= n; i ++)
    {
        if(!st[i]) primes[cnt ++] = i;  // 保存质数
        for(int j = i; j <= n; j += i)  // 删除质数的倍数
            st[j] = true;
    }
}

// 埃氏筛选法： 用质数去筛选合数，但是不能保证每个数筛选了几次
void get_primes2(int n)
{
    for(int i = 2; i <= n; i ++)
    {
        // 只需要筛选质数的倍数就行了
        if(!st[i])
        {
            primes[cnt ++] = i;   // 保存质数
            for(int j = i; j <= n; j += i) //可以用质数就把所有的合数都筛掉；
                st[j] = true;
        }
    }
}


// 线性筛选法：保证了每个合数被最小质因子筛选出来的，只筛选了一次，所以是线性的 
void get_primes3(int n)
{
    for(int i = 2; i <= n; i ++)
    {
        // 如果不是质数， 加入进去
        if(!st[i]) primes[cnt ++] = i;  // 保存质数
        // 这个筛法：是从小到大枚举所有的质数
        for(int j = 0; primes[j] <= n / i; j ++)
        {
            // 表示用primes[j] * i的最小质因数primes[j] 筛掉primes[j] * i这个合数
            // 因为此时i % primes[j] == 0一定是未成立的，因此primes[j]一定小于i的最小质因数，因此primes[j]是primes[j]*i的最小质因数
            st[primes[j] * i] = true;

			// 因为此时i % primes[j] == 0成立了，primes[j]是i的最小质因数。
			// 如果此时不break，那么primes[j]会继续向后遍历，导致primes[j]不再是i的最小质因数，也不是primes[j] * i的最小质因数
            if(i % primes[j] == 0) break;   // primes[j] 一定是i 的最小质因子
        }
    }
}

int main()
{
    int n;
    cin >> n;
    get_primes3(n);
    cout << cnt << endl;
    return 0;
}