三种质数筛（朴素、埃氏、欧拉）

三种质数筛（朴素、埃氏、欧拉）

目的：

​ 将 1 ~ N 中的质数都筛选出来。

方一、普通质数筛

思路分析：

从2到n进行遍历，对于遍历到的数如果没有被筛掉，就说明该数是素数。然后每次把遍历到的数i的倍数都筛去。为什么说这个方案可以筛出质数可行呢？因为对于一个数p，它如果没有被筛掉，就说明其不是前面2_{p-1的倍数，也就是说2}p-1不存在p的约数，这不就是素数的定义！

时间复杂度分析：O（nlogn）

对于 i = 2，需要删除n / 2个数；

对于 i = 3， 需要删除 n / 3个数

……

可以推出公式：
$$\frac{n}{2}+\frac{n}{3}+\dots \dots \frac{n}{n}=n\ast （\frac{1}{2}+\frac{1}{3}+\dots \dots \frac{1}{n}）$$
其公式满足一个调和级数，当n接近正无穷时，其值等于：
$$lnn+c=lo{g}_{e}n+c$$
又因为
$$nlo{g}_{e}n<nlo{g}_{2}n$$
所以时间复杂度记O（nlogn）

代码：

const int N = 1e6 + 5;
int n,ans=0;
int prime[N];
int vis[N];
int get_prime(int n){
    int ans=0;
    for(int i=2;i<=n;i++){
        if(!vis[i])prime[ans++]=i;//把素数存到prime数组中
        for(int j=i*2;j<=n;j+=i)vis[j]=true;//不管是合数还是质数，都用来筛掉后面它的倍数
    }
    return ans;
}
int main()
{
    cin>>n;
    cout<<get_prime(n)<<endl;
    return 0;
}
//时间复杂度：O（nlogn）

方二、埃氏筛法

思路分析：

​ 根据通过质数去把所有合数都删掉的思路，可以优化方一的普通筛法。（因为合数都可以以质数的乘积形式获得）

时间复杂度分析：O(nloglogn)

因为1~n中有n/lnn个质数，所以：
$$n\ast （\frac{1}{2}+\frac{1}{3}+\dots \dots \frac{1}{n}）=>n\ast lnn/lnn$$
要比原来的nlnn少算lnn倍，粗略估计有O（n）

但真实的时间复杂度是O（nloglogn） 很小 几乎接近O（n）

代码：

const int N = 1e6 + 5;
int n,ans=0;
int prime[N];
int vis[N];
int E_seive(int n){
    int ans=0;
    for(int i=2;i<=n;i++){
        if(!vis[i]){
        	prime[ans++]=i;
        	for(int j=i*2;j<=n;j+=i)vis[j]=true;//可以用质数把所有的合数筛掉
        }
    }
    return ans;
}
int main()
{
    cin>>n;
    cout<<E_seive(n)<<endl;
    return 0;
}
//时间复杂度：O（nloglogn）

方三、线性筛法（欧拉筛法）

结合了某位acwing中大佬的思路分析，但我忘记是谁了。

思路分析：

埃氏 和 线性 的区别 在于 埃氏 会重复删除 合数 但是 线性 不会删除重复合数，因此线性筛比埃筛快！

线性筛法的核心思路就是每个数x只会被其最小质因子筛掉，因为每个数只有一个最小质因子，所以每个数都只会被删一次，所以是线性的。

假设 i 是合数 t 的最大因数，t显然可能不唯一（例如 30 和 45 最大因数都是 15）。但是反过来从最小质数考虑，必然有
t = i * p(p为小于 i 的质数) 。
p为什么比 i 小？因为 i 是 t 的最大因数。
为什么 p 一定是质数？因为如果 p 是合数，那么 i 就一定不是 t 的最大因数，因为 p可以再拆成若干素数相乘，这些素数再与 i 相乘会使因数更大。

既然如此，我们只需要把所有小于 i 的质数 p 都挨个乘一次好了。可是，真相真的是这样的嘛？
其实不是的，一不小心就忘记了最初的条件。我们要满足 i 是 t 的最大因数。如果 p 大于 i 的最小质因数，那 i 还是 t 的最大因数嘛？显然不是，任何一个合数都能唯一分解为有限个质数的乘积，除去这其中最小的质因数，其他的都乘起来就是最大因数 i 。所以我们不能让 p 大于 i 的最小质因数。

时间复杂度：O(n)

核心代码及解释：

void get_primes(){
    //外层从2~n迭代，因为这毕竟算的是1~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]<=n/i:变形一下得到——primes[j]*i<=n,把大于n的合数都筛了就
        //没啥意义了
            st[primes[j]*i]=true;//用最小质因子去筛合数

            //1)当i%primes[j]!=0时,说明此时遍历到的primes[j]不是i的质因子，那么只可能是此时的primes[j]<i的最小质因子,所以primes[j]*i的最小质因子就是primes[j];
            //2)当有i%primes[j]==0时,说明i的最小质因子是primes[j],因此primes[j]*i的最小质因子也就应该是
            //prime[j]，之后接着用st[primes[j+1]*i]=true去筛合数时，就不是用最小质因子去更新了,因为i有最小
            //质因子primes[j]<primes[j+1],此时的primes[j+1]不是primes[j+1]*i的最小质因子，此时就应该
            //退出循环，避免之后重复进行筛选。
            if(i%primes[j]==0) break;
        }
    }
}


//我们每次要删的数是i*prime[j]
//问：
//1、为什么prime[j]就是i*prime[j]的最小质因子？
//2、为什么i%prime[j]==0我们就要退出了？
//答：
//	我们筛i*prime[j]的时候，都是满足prime[j]小于等于i的最小质因子的时候，因为对于每一个合数都可以唯一分解成有限个质数的乘积，我们把其中有限个质数最小的那个拿出来作为prime[j],那不是正好就是通过最小质数去筛掉这个合数i*prime[j]吗？如果prime[j]大于了i的最小质因子，那么对于合数i*prime[j]来说，最小质因子就不是prime[j]了，而是i中那个最小的质因子。


//对prime[j]各个状态的分析：
//1）当i%prime[j]==0 说明prime[j]*i的最小质因子也就应该是prime[j],因为我们的质数是从小到大进行遍历的，并且之后的prime[j]会大于构成i的最小质因子，所以要退出。
//2）当i%prime[j]!=0 因为从小到大遍历，质数prime[j]肯定小于构成i中的最小质因子（不然从小遍历会遍历到i的最小质因子），所以prime[j]*i的最小质因子就是prime[j]

代码：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
using namespace std;
typedef long long ll;
const int INF = 1e9;
const int N = 1e6 + 5;
int n,ans=0;
int prime[N];
int vis[N];
int get_prime(int n){
    int ans=0;
    for(int i=2;i<=n;i++){
        if(!vis[i])prime[ans++]=i;
        for(int j=0;prime[j]<=n/i;j++){
            vis[prime[j]*i]=1;
            if(i%prime[j]==0)break;
        }
    }
    return ans;
}
int main()
{
    cin>>n;
    cout<<get_prime(n)<<endl;
    return 0;
}