线性筛法

#include <iostream>  
#include <cstring>  
using namespace std;  
        
bool isPrime[1000000];  
int prime[1000000];  
int MAX, total, cnt;  
        
void makePrime() {  
    memset(isPrime,true,sizeof(isPrime));  
    memset(prime,0,sizeof(prime));  
    total = cnt = 0;  
    for(int i = 2; i <= MAX; ++i) {  
        if(isPrime[i]) prime[total++] = i;  
        for(int j = 0; j < total && i*prime[j] <= MAX; ++j) {  
            ++cnt;  
            isPrime[i*prime[j]] = false;  
//i此时不是素数,只是拓展用  
            if(i%prime[j] == 0) break;  
        }  
    }  
}  
        
int main(){  
    while(cin>>MAX){  
        makePrime();  
        cout<<total<<' '<<cnt<<endl;  
        //for(int i = 0; i < total; ++i) cout<<prime[i]<<endl;  
    }  
}

上面为线性筛法的C++代码。运行可以发现输入输出满足total + cnt = MAXN - 1，说明外层循环执行MAXN次，内层循环cnt次，每个isPrime都只会被赋值一次false，完全O(n)的筛法。

整个算法最核心的一句是if(i%prime[j] == 0) break：当i可以被某个已经找到的质数整除的时候，循环退出，不再进行剔除工作。

这样做的原因是：当prime[j]是i的因子的时候，设i=prime[j]*k

首先，我们可以肯定的说，prime[j]是i的最小质因数，这是因为第二层循环是从小到大遍历素数的

其次，我们可以肯定的说，i已经无需再去剔除prime[j']*i (j'>j) 形式的合数了，这是因为：

prime[j']*i可以写成prime[j']*(prime[j]*k)=prime[j]*(prime[j']*k)

也就是说所有的prime[j']*i将会被将来的某个i'=prime[j']*k剔除掉，当前的i已经不需要了。

bool isPrime[MAXN];
int label[MAXN], prime[MAXN];
int n, total;

void makePrime() {
    n = 100000;
    for(int i = 2; i <= n; ++i) {
        if(!label[i]) {
            prime[total++] = i;
            label[i] = total;
        }
        for(int j = 0; j < label[i]; ++j) {
            if(i * prime[j] > n) break;
            label[i * prime[j]] = j + 1;
        }
    }
    for(int i = 0; i < total; ++i) isPrime[prime[i]] = true;
}

 新偷了一个线性筛法，多了一个数组，但是速度应该比上面那个快，因为不用求余了。原理一样，就是对任意数 x ，只被它最小的那个质因子剔除一次。

void makePrime() {
    n = 10000000;
    int ed = sqrt(n + 0.5);
    memset(isPrime + 1, true, n * sizeof(bool));
    for(int i = 2; i <= n; ++i) if(isPrime[i]) {
        prime[total++] = i;
        if(i > ed) continue;
        for(int j = i * i; j <= n; j += i)
            isPrime[j] = false;
    }
}

埃氏筛法，复杂度不明（据说是O(nloglogn)），比第二个那个稍微慢一点，不过跟第一个差不多（第一个常数大……）。

对于每一个素数p，只需要筛去p×p，p×(p+1)……就可以了，因为p×q(q＜p)已经在q的第一个素因子被找到的时候被筛去了。