素数筛法

1. 埃式筛
2. 欧拉筛
3. 区间筛

1、埃式筛O(nloglogn）

最大可以处理1e7数量级的筛选
初始队列{2,3,4,5,6,7,8,9,10,11,12…}
（1）输出最小的素数2，然后筛掉2的倍数，剩下{3,5,7,9,11,13…}
(2)输出最小的素数3，然后筛掉3的倍数，剩下{5,7,11,13…}
(3)输出最小的素数5，然后筛掉5的倍数，剩下{7,11,13…}
继续以上步骤，直到队列为空

int R_sieve(int n){
	for(int i = 0; i <= n; i++) vis[i] = false;
	for(int i = 2; i * i <= n; i++)//非素数K必定可以被一个小于等于sqrt(k)的数整数
	if(!vis[i])
		for(int j = i * i; j <= n; j++)
			vis[j] = true;
	
	for(int i = 2; i <= n; i++)
		if(!vis[i])
			prime[k++] = i;
	return k;
}

例题：分解质因子
代码：

#include <iostream>
#include <math.h>
using namespace std;
typedef long long ll;
const int maxn = 1e6 + 50;
int prime[maxn];
bool vis[maxn];
int k;
ll n;
void sieve(){
    for(int i = 2; i * i < maxn; i++)
        if(!vis[i])
            for(int j = i * i; j < maxn; j += i)
                vis[j] = true;

    for(int i = 2; i < maxn; i++)
        if(!vis[i])
            prime[k++] = i;
}
bool test(ll n){
    for(int i = 0; i < k; i++)
        if(n % prime[i] == 0){
            n /= prime[i];
            if(n % prime[i] == 0) return false;
        }

    return true;
}
int main()
{
    sieve();
    int T; scanf("%d",&T);
    for(int _ = 1; _ <= T; _++){
        scanf("%lld",&n);
        bool flag = true;
        if(!test(n)) flag = false;
        if(n > 1000000){
            ll tmp = ll(sqrt(1.0 * n));
            if(tmp * tmp == n) flag = false;
        }
        if(flag) printf("Case %d: Yes\n",_);
        else printf("Case %d: No\n",_);
    }
    return 0;
}

2、欧拉筛

对于上面的埃式筛，比如12，会被26和34筛2次，而欧拉筛就保证了每个合数仅仅只被筛一次，所以复杂度可以达到O(n)。

const int maxn=100000001;
int prime[maxn];      //就是个素数表
bool sf[maxn];        //判断这个数是不是素数，sf[i]中的i是从1到maxn的数
void sushu(){         //核心 欧拉筛代码
    int num=0;        //num 用来记筛到第几个质数
    memset(sf,true,sizeof(sf));
    for(int i=2;i<=maxn;i++){          //外层枚举1~maxn
        if(sf[i]) prime[++num]=i;      //如果是质数就加入素数表
        for(int j=1;j<=num;j++){       //内层枚举num以内的质数
            if(i*prime[j]>maxn) break; //筛完结束
            sf[i*prime[j]]=false;      //筛掉...
            if(i%prime[j]==0) break;   //避免重复筛
        }
    }
    sf[1]=false;
    sf[0]=false;  //1 0 特判 
}

欧拉筛详细可见：欧拉筛

3、区间素数

对于前面两种筛法，相同的是，要筛出[a,b]的素数，只需要[2,√b]的就行了，所以，首先先筛出[2,√b]中的素数，然后再把[2,√b]的素数筛出[a,b];

const int maxn = 1e6 + 50;
bool is_prime[maxn];
bool is_prime_small[maxn];
void segment_sieve(ll a, ll b){
    for(int i = 0; (ll)i * i < b; i++) is_prime_small[i] = true;
    for(int i = 0; i < b - a; i++) is_prime[i] = true;

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

解释一下max(2LL, (a + i - 1) / i)。首先，j不能小于a。如果a%i ！= 0，那么 (a / i) * i < a，那 j - a < 0,数组越界，所以要加i,保证了j一定大于a，如果a % i == 0，那么(a + i )/ i * i 会漏筛a。所以（a + i）/ i * i是必须的。
典型例题：区间素数
贴一下ac代码：

#include <iostream>
using namespace std;
typedef long long ll;
const int maxn = 1e6 + 50;
const int model = 998244353;
int prime[maxn], k = 0, K;
bool vis[maxn];
ll l,r,sum;
ll val[maxn],ans[maxn];
void sieve(){
    for(int i = 2; i * i <= maxn; i++)
        if(!vis[i])
            for(int j = i * i; j <= maxn; j += i)
                vis[j] = true;

    for(int i = 2; i <= maxn; i++)
        if(!vis[i])
            prime[k++] = i;
}
int Solve(){
    for(ll i = l; i <= r; i++){
        val[i - l] = i;
        ans[i - l] = 1;
    }
    for(int i = 0; 1ll * prime[i] * prime[i] <= r; i++){
        int v = prime[i];
        for(ll j = max(2LL, (l + v - 1) / v) * v; j <= r; j += v){
            int cnt = 0;
            while(val[j - l] % v == 0) val[j - l] /= v,cnt++;
            ans[j - l] = (1 + K * cnt) % model * ans[j - l] % model;
        }
    }

    for(ll i = l; i <= r; i++)
        if(val[i - l] != 1) ans[i - l] = (1 + K) * ans[i - l] % model;
    ll sum = 0;
    for(int i = 0; i < r - l + 1; i++)
        sum = (sum + ans[i]) % model;
    return int(sum);
}
int main(){
    sieve();
    int T; scanf("%d",&T);
    while(T--){
        scanf("%lld%lld%d",&l,&r,&K);
        printf("%d\n",Solve());
    }
}

最后，因为素数总是跟因子，除数挂钩，了解了唯一分解定理这个东西，就是所有的合数都能分解成素数的乘积：
n = p1(a1) * p2(a2) * p3(a3)…（a1,a2,a3…为指数）
n的因子数为：(1 + a1) * (1 + a2) * (1 + a3)…
因为对于所有的素数因子，p1的次方可以取0,1,2,3,…,a1，总共有1 + a1总。
n的k次方 = (1 + ka1) * (1 + ka2) * (1 + k*a3)…
上面的式子两边同时取k次方就行了