素数筛的不同方法

出处：AcWing 868. 筛质数 - AcWinghttps://www.acwing.com/solution/content/68127/

前置知识：

• 自然数按因数的个数分：质数、合数、00、11 四类
• 最小的质数是 22，最小的合数是 44，连续的两个质数是 22、33
• 每个合数都可以由几个质数相乘得到，即合数等于质数之积，质数相乘一定得到合数
• 除了 22 和 55，其余质数的个位都是 1、3、7、91、3、7、9
• 质数定理：当 n→∞n→∞ 时，1∼n1∼n 中的质数个数为 。

朴素筛： O(nlogn)

任何整数 xx 的倍数 2x,3x,⋯2x,3x,⋯ 都不可能是素数。我们可以从 22 往后扫描，将当前数的所有倍数全部筛掉，剩下没有被筛掉的数就是质数。

埃式筛：O(nloglogn)

若按照之前的筛法筛去一个整数的所有倍数，我们最终会留下一些质数，以 pp 为例，说明 pp 不是 2∼p−12∼p−1 内任何一个数的倍数，我们并不需要将 2∼p−12∼p−1 内所有的数依次枚举一遍，只要将其中的质数枚举一遍即可，因为合数等于质数之积。

线性筛：O(n)

埃氏筛存在一个缺陷，即对于一个合数，可能会被筛多次，例如 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∼n2∼n 之间，因此合数最大为 nn，故 primes[j] * i 只需枚举到 n 即可，但由于 primes[j] * i 可能会溢出整数范围，故改成 primes[j] <= n / i 的形式。

#include <iostream>
#include <cstdio>
#include <algorithm>

using namespace std;
const int N = 1e6 + 10;
int primes[N], cnt;
bool st[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 + i; j <= n; j += i ) st[j] = true;
    }
}

//埃式筛，时间复杂度O(nloglogn)
void get_prime(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;
        }
    }
}
*/

//线性筛，时间复杂度O(n)
void get_prime(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;
        }
    }
}

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

附上普通的分解质因数的代码（内涵算术基本定理）：

#include <iostream>
#include <algorithm>
//时间复杂度介于O(logn)和O(sqrt(n))之间
using namespace std;

/*算术基本定理(也称唯一分解定理)：
任何一个大于1的自然数N，都可以分解成一些质数的乘积（即某些质因子的乘积），并且在
不计次序的情况下，这种分解方式是唯一的。
即有公式: N = P1^a1 * P2^a2 * P3^a3* ...... Pn^an;
一个数中只存在一个大于sqrt(n)的质因数，因为如果有两个，那么乘出来
肯定大于N
*/
void divide(int n)
{
    for(int i = 2; i <= n / i; ++i)
        if(n % i == 0)
        {
            //这样子找是不会找出来合数的，因为是从最小的质数
            //2开始找的，所以如果找到一个合数，那么这个合数肯定
            //能被前面比它小的质数表达出来，而这些质数已经在n中
            //被除去了，也就是i肯定没有从2到i-1中的约数
            //然后看看这个质数在乘积中出现了几次
            int s = 0;
            while(n % i == 0)
            {
                n /= i;//把找到的质因数除掉，这样上方公式中的N中就没有
                       //这个质数了
                s++;
            }
            printf("%d %d\n", i, s);
        }
    if(n > 1)//看看有没有大于sqrt的质因数
        printf("%d %d\n", n, 1);
    printf("\n");
}

int main()
{
    int n;
    scanf("%d", &n);
    while(n--)
    {
        int x;
        scanf("%d", &x);
        divide(x);
    }
    return 0;
}