各种筛子

埃筛

从 2～n 默认全为素数，开始枚举。枚举判定是否为素数。
如果是，就将它的所有倍数判定为合数。
如果不是，直接跳过。

#include<cstdio>
const int N = 100000 + 5;
bool prime[N];
void init(){
    for(int i = 2; i < N; i ++) prime[i] = true;
    for(int i = 2; i*i < N; i ++){//判断改成i*i<N 
        if(prime[i]){
            for(int j = i*i; j < N; j += i){//从i*i开始就可以了 
                prime[j] = false;  
            }
        }
    }
}
int main(){
    init();
}

线性

也是默认 2～n 全为素数。枚举判定是否为素数。
如果是，就储存起来（真素数），再将已经知道的真素数的当前数（i）倍判定为合数（每个合数只能筛一次，才能保证是O（n）的复杂度，即每个合数只能够被最小的因素数筛掉）

#include<cstdio>
const int N = 100000 + 5;
bool prime[N];//prime[i]表示i是不是质数 
int p[N], tot;//p[N]用来存质数 
void init(){
    for(int i = 2; i < N; i ++) prime[i] = true;//初始化为质数 
    for(int i = 2; i < N; i++){
        if(prime[i]) p[tot ++] = i;//把质数存起来 
        for(int j = 0; j < tot && i * p[j] < N; j++){
            prime[i * p[j]] = false;
            if(i % p[j] == 0) break;//保证每个合数被它最小的质因数筛去 
        }
    }    
}
int main(){
    init();
}

当然我们可以证明一下神奇的 if 的作用。

if(i % p[j] == 0) break;

目的：保证每个合数被它最小的质因数筛去
证明：
i 有因子 p[ j ]，即 i = k * p[ j ]
那么 i * p[ j+1 ] = k * p[ j ] * p[ j+1 ]
而我们知道数组 p 是递增的，那么显然 p[ j ] 能筛了它

线筛另一种写法
（来自算法竞赛进阶指南）

int v[maxn];//记录最小质因子
int prime[maxn];//记录质数
memset(v,0,sizeof(v));
int m=0;//记录质数个数
for(int i=2;i<=n;i++){
    if(v[i]==0){
        //如果没有最小质因子，即之前未处理过
        v[i]=i;
        prime[++m]=i;
    }
    //枚举已知的质数
    for(int j=1;j<=m;j++){
        //线性的关键
        if(v[i] < prime[j]||i*prime[j]>n)break;
        prime[i * prime[j]]=prime[j];
    }
}

欧拉筛

求欧拉函数利用这两条性质，可以达到 O（n）的处理

1. $p|n,p^2|n\to \varphi (n)=\varphi (n/p)\ast p$
2. $p|n,p^2\nmid n\to \varphi (n)=\varphi (n/p)\ast (p-1)$

类似于线性筛的写法吧，每个数只能筛一次！

int v[maxn];//记录最小质因子
int prime[maxn];//记录质数
int phi[maxn];//欧拉函数值
memset(v,0,sizeof(v));
int m=0;//记录质数个数
for(int i=2;i<=n;i++){
    if(v[i]==0){
        //如果没有最小质因子，即之前未处理过
        v[i]=i;
        prime[++m]=i;
        phi[i]=i-1;
    }
    //枚举已知的质数
    for(int j=1;j<=m;j++){
        //线性的关键
        if(v[i] < prime[j]||i*prime[j]>n)break;
        prime[i * prime[j]]=prime[j];
        phi[i * prime[j]]=phi[i]*(i%prime[j]?prime[j]-1:prime[j]);
    }
}