质数——埃式筛法和欧式筛法

最新推荐文章于 2025-11-05 16:15:39 发布

原创最新推荐文章于 2025-11-05 16:15:39 发布 · 3.6k 阅读

13 ·

CC 4.0 BY-SA版权

信息学介绍专栏收录该内容

3 篇文章

订阅专栏

本文详细介绍了埃拉托斯特尼筛法（埃氏筛）、欧几里得筛法和区间筛在寻找素数过程中的原理、优缺点，并提供了相应的C++代码示例。了解这些高效算法对于提高编程效率和理解素数判定至关重要。

埃氏筛法原理

素数的定义：素数就是除了1和本身之外没有其他的约数，所以有约数的都不是素数。

埃氏筛法的思想就是：先去掉2的倍数，再去掉3的倍数，再去掉4的倍数，……依此类推，直到最大数小于最后一个标出的素数的平方，那么剩下的序列中所有的数都是素数。时间复杂度：O(nloglogn)
代码如下：

#include<bits/stdc++.h>
#define maxn 10000000
#define INF 0x3f3f3f3f
using namespace std;
bool a[maxn+5];
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    memset(a,true,sizeof(a));
    for(int i=2;i<=n;i++){
        if(a[i]){
            for(int j=2;i*j<=n;j++)
                a[i*j]=false;
        }
    }
    a[1]=false;
    int t;
    while(m--)
    {
        scanf("%d",&t);
        if(a[t])printf("Yes\n");
        else printf("No\n");
    }
    return 0;
}

欧拉筛法

在埃式筛法中，存在有些数存在重复筛的情况，如：385这个数，385= 5 * 7* 11，会被5的倍数时标记一次，7的倍数时标记一次，11的倍数时标记一次，造成效率达不到最优。而线性筛法基于改进这个不足的基础上，在线性时间内，也就是O(n)，用筛选的方法把素数找出来。

 核心原理：对于每个合数，都只由它最小的质因子筛掉。 
 比如：（假定：ans[]数组中存放着已经确定的素数）合数 i = p（最小素因子）* a;  若 i%ans[j] ==0; 
 则 i * ans[j+1] =  p * a * ans[j+1] 可以被后面的 a * ans[j+1] 再乘以素数 p 筛选出来，(显而p<ans[j+1]） 所以i%ans[j] == 0 时要停止。

代码如下：

#include<bits/stdc++.h>
#define maxn 10000000
#define INF 0x3f3f3f3f
using namespace std;
bool a[maxn+5];
int b[maxn+5];//存储质数
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    memset(a,true,sizeof(a));
    a[1]=false;
    int k=1;
    for(int i=2;i<=n;i++){
        if(a[i])   //如果i为质数
            b[k++]=i;//存上
        for(int j=1;j<=k&&i*b[j]<=n;j++){
            a[i*b[j]]=false;
            if(i%b[j]==0)break;
        }
    }
    int t;
    while(m--){
        scanf("%d",&t);
        if(a[t])printf("Yes\n");
        else printf("No\n");
    }
    return 0;
}

四种素数筛法：朴素素数筛，埃氏筛，欧拉筛和区间筛详解

预备知识：

1.算术基本定理：任何一个大于1的自然数 N,如果N不为质数，那么N可以唯一分解成有限个质数的乘积
2. 若一个数可以进行因数分解，则得到的两个数一定是有一个>=sqrt(x),另一个<=sqrt(x).

朴素算法

复杂度：O(n√n)
介绍：这个算法是最简单的素数判断算法+遍历素组，耗时长

#include<bits/stdc++.h>
#define maxn 1000010
#define ll long long
using namespace std;
int prime[maxn];
bool judge(ll x)
{   
    if(x==2) return true;
    if(x<2||x%2==0)
        return false;   
    for(int i=3;i<=sqrt(x+1);i+=2)//这个地方可以优化一下，一个是范围，一个是步长 （素数一定是奇数） 
        {
            if(x%i==0)
                return false;
        }
    return true;
}
int sieve(int n)
{
    int p=0;
    for(int i=0;i<=n;i++)
        if(judge(i))
            {
            prime[p++]=i;}
    return p;   
}
int main()
{
    int n;
    cin>>n;
    cout<<sieve(n)<<endl;

}

2.埃氏筛法

复杂度：O(nloglogn)
介绍：埃拉托斯特尼筛法，利用当前已经找到的素数，从后面的数中筛去当前素数的倍数，由预备知识一可知，当前素数已经是筛去数的质因子，如此下去能筛除所有之后的合数，是一种比较快的筛法

#include<bits/stdc++.h>
#define maxn 1000010
#define ll long long
using namespace std;
int prime[maxn];
bool is_prime[maxn];
int sieve(int n)
{   
    memset(is_prime,true,sizeof(is_prime));//注意初始化 
    int p=0;
    is_prime[0]=is_prime[1]=false;
    for(int i=2;i<=n;i++)
    {
        if(is_prime[i])
        {   
            prime[p++]=i;
            for(int j=2*i;j<=n;j+=i)//美中不足是会筛除多次比如8和16，同时被2和4筛去
                is_prime[j]=false;              
        }

    }
return p;   
}
int main()
{
    int n;
    cin>>n;
    cout<<sieve(n)<<endl;

}

3.欧几里得筛法

复杂度：O（N）
介绍：这是一种很好的线性筛法，和埃氏筛法的区别是对于每一个要筛除的数，欧拉筛法只筛除一次，而埃氏筛法会重复筛除，比如8和16同时被2和4筛去，推荐使用欧拉筛法

#include<bits/stdc++.h>
#define maxn 1000010
#define ll long long
using namespace std;
int prime[maxn];
int factor[maxn];//用来记录最小素因子 
int sieve(int n)
{   
    int p=0;
    for(int i=2;i<=n;i++)
    {
        if(!factor[i])//如果没有找到素因子，当然就是素数啦 
        {
            prime[p++]=i;
            factor[i]=i;            
        }
        for(int j=0;j<p&&prime[j]*i<=n;j++)
        {
            factor[prime[j]*i]=prime[j];
            if(!(i%prime[j]))//筛的数已经被前面的数筛过了 
                break;      
        }   
    }
    return p;   
}
int main()
{
    int n;
    cin>>n;
    cout<<sieve(n)<<endl;

}

区间筛法

介绍：对于于超大区间，如a<’b<=10^12,b-a<=10^6,这种情况下，数组是开不到这么大的，所以要用偏移来筛选，具体是先打一个2-√b的小表,然后用此表来筛除a到b的素数

#include<bits/stdc++.h>
#define ll long long
#define maxn 1000005 
using namespace std;
bool is_prime[maxn];
bool is_prime_small[maxn];
ll ans=0;
void segment_sieve(ll a,ll b)
{   
    for(ll i=0;i*i<b;i++)   is_prime_small[i]=true;
    for(ll i=0;i<b-a;i++)   is_prime[i]=true;

    for(ll i=2;i*i<b;i++)
    {
        if(is_prime_small[i])
            {
                for(ll j=2*i;j*j<b;j+=i) is_prime_small[j]=false;
                for(ll j=max((long long)2,(a+i-1)/i)*i;j<b;j+=i) is_prime[j-a]=false;                   

            }       

    }
} 
int main()
{

    ll a,b;
    cin>>a>>b;
    segment_sieve(a,b);
    for(ll i=0;i<b-a;i++)   
        if(is_prime[i])
            ans++;  

    cout<<ans<<endl;    

}