质数筛法总结

大体思路：通过筛选，依次将n以内的所有质数存入$prime[]$数组，a[]组中任意元素$a[i]$，当$a[i]==0$时，表示$i$是质数，$a[i]==1$时表示$i$是合数。

基本概念

质数

只有两个正因数（1和它本身）的自然数即为质数

合数

是指除了1和其本身外还有其他正因数的大于1的正整数。

依定义，每一个大于1的整数不是素数就是合数。而1则被认为既不是素数，也不是合数。

那么，在一张写有2~n的数字表里，将所有合数删去，剩下的就是质数了。

唯一分解定理‌

也称为算术基本定理，是数论中的一个基本定理。它表明任何一个大于1的自然数（除了质数本身）都可以唯一地分解为有限个质数的乘积。具体来说，对于任意大于1的自然数N，可以表示为$N=P_1^{a_1}\ast P_2^{a_2}\ast \cdots \ast P_n^{a_n}$，其中$P_1,P_2,\dots ,P_n$是质数，$a_i$是正整数。

普通筛

伪代码描述：

for（i:2~n）{
	if(a[i]==0){
		把i加到prime[]数组
	}
	将i的倍数标记为合数
}

例如：数x，那么2x，3x，4x……肯定是合数，顾可筛去

如图，可以发现有些合数重复删除了很多次，这是因为有些合数的例如：24=212=38=46=64=83=12*2，即2的倍数、3的倍数、4的倍数、6的倍数、8的倍数、12的倍数都删过24这个数字。

代码实现

#include<iostream>
using namespace std;
bool a[1000000];
int n;//质数筛的上限范围
int prime[100000];
int pIndex=0;
int main(){
	cin>>n;
	for(int i=2;i<=n;i++){
		if(a[i]==0){//i是质数
			prime[pIndex]=i;
			pIndex++;
		}
		for(int j=2;i*j<=n;j++){
			a[i*j]=1;//将i的倍数标记为合数
		}
	}
	//输出所有质数
	for(int i=0;i<pIndex;i++){
		cout<<prime[i]<<endl;
	}
return 0;
}

其实根据唯一分解定理，不必每个数的倍数都筛，只要筛掉质数的倍数就够了。于是有了下面的埃氏筛法。

埃氏筛法

伪代码描述：

for（i:2~n）{
	if(a[i]==0){//i是质数
		把i加到prime[]数组
		将i的倍数标记为合数
	}
}

由上图可见，重复删数的次数减少了，但是仍有数字被重复删去；后面的欧拉筛解决了这个问题。

代码实现

#include<iostream>
using namespace std;
bool a[1000000];
int n;//质数筛的上限范围
int prime[100000];
int pIndex=0;
int main(){
	cin>>n;
	for(int i=2;i<=n;i++){
		if(a[i]==0){
			prime[pIndex]=i;
			pIndex++;
			for(int j=2;i*j<=n;j++){
				a[i*j]=1;//将质数i的倍数标记为合数
			}
		}
	}
	//输出所有质数
	for(int i=0;i<pIndex;i++){
		cout<<prime[i]<<endl;
	}	
return 0;
}

欧拉筛

造成埃氏筛法中重复删去同一个数字的情况有两种：
1.以数值24举例，$24=2\ast 12=3\ast 8$
2.以数值6举例，$6=2\ast 3=3\ast 2$
第二种情况比较好解决，在质数乘以倍数时，控制倍数必须大于等于质数即可。也就是下方代码中j的初值由2改为i。

for(int i=2;i<=n;i++){
		if(a[i]==0){
			prime[pIndex]=i;
			pIndex++;
			for(int j=2;i*j<=n;j++){
				a[i*j]=1;//将质数i的倍数标记为合数
			}
		}
	}

for(int i=2;i<=n;i++){
		if(a[i]==0){
			prime[pIndex]=i;
			pIndex++;
			for(int j=i;i*j<=n;j++){
				a[i*j]=1;//将质数i的倍数标记为合数
			}
		}
	}

对于第一种情况的处理，就是欧拉筛的思想核心了。由于一个合数可能若干个质因子，通过构造质数倍数的方法制造合数时，就有可能不同方法构造出同一个数，那么如果只用最小的质数构造合数呢？这样24这个数值就只在212时被删去，因为2 是24的最小质数。
设合数x=pq,其中q为x的最小质数，根据唯一分解定理，每一个合数都可以表示为最小质数乘以另一个数（可以是质数也可以是合数）的结构。以前20个数为例，么个合数通过“最小质数*一个数”的结构被删除，且只删除一次
$2$
$3$
$4=2\ast 2$
$5$
$6=2\ast 3$
$7$
$8=2\ast 4$
$9=3\ast 3$
$10=2\ast 5$
$11$
$12=2\ast 6$
$13$
$14=2\ast 7$
$15=3\ast 5$
$16=2\ast 8$
$17$
$18=2\ast 9$
$19$
$20=2\ast 10$
……
这个算法最有趣的地方在于控制最小质数。

for（i:由前往后遍历prime[]){
	for(j=i;i*j<=n;j++){
	此时i*j要想保证j的质因子里中没有比i更小的质数p，
	就需要对j进行判断，找到j的最小质因数并与i比较是否小于等于i
	}
}

但是如果将内外循环互换一下：

for（i:2~n){
	for(j:由前往后遍历prime[]){
	由于prime[]里的质数是由小到大存储的
	在标记完i*j后,只需要用条件i%j==0,判断一下：
	如果i%j==0成立，那么停止遍历prime数组，找到i中最小的质因子即j是i的最小质因子；
	如果继续遍历prime数组，那一定不是最小质数*i的结构。
	}
}

伪代码描述：

//由于是由小到大筛的质数，所以prime数组里的质数也是由小到大保存的。
//即有任意质数prime[i],则prime[i+1]>prime[i]
for（i:2~n）{
	if(a[i]==0){//i是质数
		把i加到prime[]数组
	}
	//正序遍历prime[]数组，用当前的每个质数乘以i
	for(int j=0;j<pIndex;j++){
		a[prime[j]*i]=1;
		if(i%prime[j]==0)
			break;
	//中断后，后面的质数不用再和i相乘
	//因为prime[j+1]*i,不是“最小质数*一个数的结构”,i中包含更小的质数prime[j]。
	}
}

大家可以按着伪代码描述，自己模拟一下筛数的过程。

代码实现

#include<iostream>
using namespace std;
bool a[1000000];
int n;//质数筛的上限范围
int prime[100000];
int pIndex=0;//pIndex始终指向最后一个质数的后一个位置
int main(){
	cin>>n;
	for(int i=2;i<=n;i++){
		if(a[i]==0){
			prime[pIndex]=i;
			pIndex++;
			}
		for(int j=0;j<pIndex;j++){
			if(i*prime[j]<=n){
				a[i*prime[j]]=1;
			}
			if(i%prime[j]==0)break;//有趣的是这句话还控制住了类似2*6,6*2这种重复构造的情况，
			//因为2%2==0，所以当i=2时，最大只能乘到2这个质数。12这个数是在i=6的时候删除的。
		}
	}
	//输出所有质数
	for(int i=0;i<pIndex;i++){
		cout<<prime[i]<<endl;
	}	
return 0;
}