欧拉线性筛法求素数

我们先来看一下最经典的埃拉特斯特尼筛法。时间复杂度为O(n loglog n)

[cpp] view plain copy

print ?

1. int ans[MAXN];  
2. void Prime(int n)  
3. {  
4.     int cnt=0;  
5.     memset(prime,1,sizeof(prime));  
6.     prime[0]=prime[1]=0;  
7.     for(int i=2;i<n;i++)  
8.     {  
9.         if(vis[i])  
10.         {  
11.            ans[cnt++]=i;//保存素数   
12.            for(int j=i*i;j<n;j+=i)//i*i开始进行了稍微的优化  
13.            prime[j]=0;//不是素数   
14.         }  
15.     }  
16.     return ;  
17. }  

int ans[MAXN]; 

void Prime(int n) 

{ 

    int cnt=0; 

    memset(prime,1,sizeof(prime)); 

    prime[0]=prime[1]=0; 

    for(int i=2;i<n;i++) 

    { 

        if(vis[i]) 

        { 

           ans[cnt++]=i;//保存素数  

           for(int j=i*i;j<n;j+=i)//i*i开始进行了稍微的优化 

           prime[j]=0;//不是素数  

        } 

    } 

    return ; 

}

显然，当一个数是素数的时候，那么他的倍数肯定是合数，筛选标记即可。从i*i而不从i*2开始，是因为已经i*3，i*2早已经被2，3筛过了。

由此，我们也可以发现有的合数被重复筛除，例如30，2*15筛了一次，5*6重复筛除，所以也就有了我们下面要提到的欧拉线性筛法。

不会重复筛除，是线性O（n）的复杂度。

[cpp] view plain copy

print ?

1. const int MAXN=3000001;  
2. int prime[MAXN];//保存素数   
3. bool vis[MAXN];//初始化   
4. int Prime(int n)  
5. {  
6.     int cnt=0;  
7.     memset(vis,0,sizeof(vis));  
8.     for(int i=2;i<n;i++)  
9.     {  
10.         if(!vis[i])  
11.         prime[cnt++]=i;  
12.         for(int j=0;j<cnt&&i*prime[j]<n;j++)  
13.         {  
14.             vis[i*prime[j]]=1;  
15.             if(i%prime[j]==0)//关键   
16.             break;  
17.         }  
18.     }  
19.     return cnt;//返回小于n的素数的个数   
20. }  

const int MAXN=3000001;
int prime[MAXN];//保存素数 
bool vis[MAXN];//初始化 
int Prime(int n)
{
    int cnt=0;
    memset(vis,0,sizeof(vis));
    for(int i=2;i<n;i++)
    {
        if(!vis[i])
        prime[cnt++]=i;
        for(int j=0;j<cnt&&i*prime[j]<n;j++)
        {
            vis[i*prime[j]]=1;
            if(i%prime[j]==0)//关键 
            break;
        }
    }
    return cnt;//返回小于n的素数的个数 
}

首先，先明确一个条件，任何合数都能表示成一系列素数的积。
然后利用了每个合数必有一个最小素因子，每个合数仅被它的最小素因子筛去正好一次。所以为线性时间。
代码中体现在：
if(i%prime[j]==0)break;
prime数组 中的素数是递增的,当 i 能整除 prime[j]，那么 i*prime[j+1] 这个合数肯定被 prime[j] 乘以某个数筛掉,即(i*prime[j+1])的最小素因子不是prime[j+1],而是prime[j],已经被晒掉了
因为i中含有prime[j], prime[j] 比 prime[j+1] 小。接下去的素数同理。所以不用筛下去了。
在满足i%prme[j]==0这个条件之前以及第一次满足改条件时,prime[j]必定是prime[j]*i的最小因子。

如果还不是很理解，可以手动模拟一下。