素数筛法详解：埃氏筛和欧拉筛

超级详细的基础算法和数据结构合集：
https://blog.csdn.net/GD_ONE/article/details/104061907

摘要

本文主要介绍埃氏筛法和欧拉筛法。
之前讲了怎么判断一个数是不是质数，现在求区间 $[1, 1e7]$内所有的质数。我们将用到埃氏筛和欧拉筛。

埃式筛

埃拉托斯特尼筛法，简称埃氏筛。

学习埃氏筛之前，我们先看一下暴力筛法，即对每个数都用试除法判断其是不是质数：

暴力筛法：

static final int N = 1e7 + 5;
int st[N]; // 初始化为0， 0表示质数，1表示合数

for(int i = 2; i <= n; i++){
	for(int j = 2; j <= i / j; j++){//试除法
		if(i % j == 0){
			st[i] = 1; // 合数，标记为1 
		}
	}
}

这种方式无疑是最慢的，我们看一下如何加快，换一种思路：一个质数的倍数一定是合数，所以，假设 $P$是质数，我们可以筛掉区间 $[1,1e7]$中所有 $P$的倍数。
先看个例子，对于数列1~11：

先筛去2的倍数：

然后筛去3的倍数：

然后筛去5的倍数：

至此，1~11内的所有合数都被筛完了， 2 3 5 7 11是数列中的质数。
为什么这样能筛去所有的合数呢，因为一个合数一定能被分解为几个质数的幂的乘积，并且这个数的质因子一定是小于它本身的，所以当我们从小到大将每个质数的倍数都筛去的话，当遍历到一个合数时，它一定已经被它的质因子给筛去了。

埃氏筛代码：

static final int N = 1e7 + 5;
static int[] st = new int[N];
public static void E_sieve(int  n){

	for(int i = 2; i <= n; i++)
	{
		if(st[i] == 0)
		{
			for(int j = 2 * i; j <= n; j += i)
			    st[j] = 1; // j是i的一个倍数，j是合数，筛掉。
		}
	}
	
}

以上代码的时间复杂度为： $O(nloglog_2n)$;
我们还可以对其进行优化：

1. 我们会先筛2的所有倍数，然后筛3的所有倍数，但筛除3的倍数时，我们还是从3的2倍开始筛，其实3 * 2 ，已经被2 * 3时筛过了。
   又比如说筛5的倍数时，我们从5的2倍开始筛，但是5 * 2会先被2 * 5筛去， 5 * 3会先被3 * 5会筛去，5 * 4会先被2 * 10筛去，所以我们每一次只需要从i*i开始筛，因为(2，3,…,i - 1)倍已经被筛过了。

2. 另外，判断一个数 $n$是不是质数，我们只判断 $[2, \sqrt{n} ]$内有没有它的因子。在筛合数的时候，我们也可以这样做，因为一个合数的最小质因子一定小于等于 $\sqrt{n}$。
   所以对于区间 $[1, 1e7]$，最大的合数是 $1e7$, 它的最小质因子一定是小于等于 $\sqrt{1e7}$，区间内其他的合数的最小质因子也一定是小于等于 $\sqrt{1e7}$的，所以只需要用 $[1, \sqrt{1e7}]$中的质数就可以筛去 $[1, 1e7]$中所有的合数。

优化后的埃式筛：

static final int N = 1e7 + 5;
static int[] st = new int[N];
public static void E_sieve(int  n){

	for(int i = 2; i <= n / i; i++)
	{
		if(st[i] == 0)
		{
			for(int j = i * i; j <= n; j += i)
			    st[j] = 1; // j是i的一个倍数，j是合数，筛掉。
		}
	}
	
}

优化后的时间复杂度可以近似看成 $O(n)$了。
但是，我们还可以更快，那就是欧拉筛。

欧拉筛

欧拉筛，又称为线性筛，时间复杂度为 $O(n)$。
先看下代码再看解析：

static final int N = 1e7 + 5;
static int[] st = new int[N], primes = new int[N];
void ola(int n)
{
    for (int i = 2; i <= n; i ++ )
    {
        if (st[i] == 0) primes[cnt ++ ] = i;//将质数存到primes中
        for (int j = 0; primes[j] <= n / i; j ++ )//要确保质数的第i倍是小于等于n的。
        {
            st[primes[j] * i] = 1;
            if (i % primes[j] == 0) break;
        }
    }
}

埃氏筛是筛去每个质数的倍数，但难免，会有合数会被其不同的质因子多次重复筛去。这就造成了时间浪费。

比如说： $120 = 2^3 * 3 * 5$
120 会被2筛去一次， 3筛去一次， 5筛去一次。
多做了两次不必要的操作。

那么我们如何确保120只被2筛掉呢？
在埃氏筛中我们用了一个循环来筛除一个质数的所有倍数，即对于p来说，筛除数列： $2 * p , 3 * p, ... , k*p$
另外，我们是从小到大枚举区间中的每个数的，数列是： $2,3,4,...,n$
对比两个数列：

$2*p, 3 * p, ... , k*p$
$2，　3，....　n$

会发现，第二个数列是第一个数列的系数。
所以，我们不需要用一个for循环去筛除一个倍数的所有质数，我们将质数存储到primes[]中，然后枚举到第i个数时，筛去primes[j] * i

如果 $i \% primes[j] == 0$ , 我们就结束内层循环，为什么呢？
下面的很重要：
因为：

1 ： $i \% primes[j] == 0$
2 ： $primes[j] * k = i$

设：
3： $primes[j+1] * i = X$

将2式带入3中得： $primes[j+1] * primes[j] *k = X$

因为： $primes[j+1] > primes[j]$, 所以： $primes[j+1]*k > i$

设 $primes[j+1]*k = i'$

则：4： $primes[j]*i' = X$

所以如果用3式筛去 $X$的话，当 $i$等于 $i'$时， $X$又会被4式筛去一次，为了确保合数只被最小质因子筛掉，最小质因子要乘以最大的倍数，即要乘以最大的 $i$, 所以不能提前筛。

比如说 1 ，2，3，4，5，6，7，8，9，10，11， 12
当 $i == 4时：$ primes = {2, 3}
此时 $i\%2 == 0$, 如果不结束内层循环的话， 12会被 $3*4$筛掉， 当 $i == 6$时，12又会被 $2*6$筛掉。

欧拉筛的核心思想就是确保每个合数只被最小质因数筛掉。或者说是被合数的最大因子筛掉。

例题：
筛质数

代码：

import java.io.*;
import java.util.*;

public class Main{
    static final int N = 10000005;
    static int[] primes = new int[N];
    static int[] st = new int[N];
    
    static int cnt = 0;
    public static void ola(int n){
      
        for(int i = 2; i <= n; i++)
        {
            if(st[i] == 0)	primes[cnt++] = i;
            
            for(int j = 0; primes[j] <= n / i; j++)
            {
                st[primes[j]*i] = 1;
                if(i % primes[j] == 0) break;
            }
        }
    }
    
    public static void main(String[] args){
       Scanner in = new Scanner(new InputStreamReader(System.in));
       int a;
       a = in.nextInt();
       
       ola(a);
       System.out.println(cnt);
    }
}