筛质数

常用的有3种算法，分别有不同的用途。

1. 暴力枚举 O(sqrt(n)) 常用于判断单个或少量数是否质数
2. 一般的线性筛 O(n^2) 常数挺小，常用于O(1)查找是否质数，但需要开O(n)大小的数组
3. 快速线性筛（欧拉筛） O(n)，虽然代码表面上看起来时间复杂度并不是O(n)

实现：

• 暴力枚举

代码：

ok = 1;
if(n < 2 || n % 2 == 0) ok = 0; //偶数肯定不是
else
	for(i = 3; i <= sqrt(n); i += 2) //奇数
		if(n % i == 0)
		{
			ok = 0;
			break;
		}
cout << (ok?"YES":"NO");

• 线性筛

代码：

bool notprime[MAXN];
for(i = 2; i <= sqrt(n); i++)
{
	j = 2; t = i<<1;
	while(t<=m) 
		notprime[t] = 1, t = i*(++j);
}
int ask;
cin >> ask;
while(ask--)
{
	cin >> t;
	cout << (notprime[t]?"NO":"YES");
}

• 欧拉筛

（部分转自http://blog.csdn.net/dinosoft/article/details/5829550）

快速线性筛法没有冗余，不会重复筛除一个数

int prime[MAXN], num_prime = 0;    
int isNotPrime[MAXN] = {1, 1};   
for(int i = 2; i <= N; i++)       
{
	if(!isNotPrime[i])               
	 	prime[num_prime++] = i;  
	//关键处1        
	for(int j = 0; j < num_prime && i * prime[j] <= N; j++)
	{
		isNotPrime[i * prime[j]] = 1;
		if(!(i % prime[j]))  //关键处2
			break;
	}
}

证明：

首先，先明确一个条件，任何合数都能表示成一系列素数的积。

不管 i 是否是素数，都会执行到“关键处1”，

1. 如果 i 都是是素数的话，那简单，一个大的素数 i 乘以不大于 i 的素数，这样筛除的数跟之前的是不会重复的。筛出的数都是 N=p1*p2的形式, p1，p2之间不相等
2. 如果 i 是合数，此时 i 可以表示成递增素数相乘 i=p1*p2*...*pn, pi都是素数（2<=i<=n），  pi<=pj  ( i<=j )

p1是最小的系数。

根据“关键处2”的定义，当p1==prime[j] 的时候，筛除就终止了，也就是说，只能筛出不大于p1的质数*i。

我们可以直观地举个例子。i=2*3*5

此时能筛除 2*i ,不能筛除 3*i

如果能筛除3*i 的话，当 i' 等于 i'=3*3*5 时，筛除2*i' 就和前面重复了。

需要证明的东西：

1. 一个数会不会被重复筛除。
2. 合数肯定会被干掉。

根据上面红字的条件，现在分析一个数会不会被重复筛除。

设这个数为 x=p1*p2*...*pn, pi都是素数（1<=i<=n)  ,  pi<=pj ( i<=j )

当 i = 2 时，就是上面①的情况，

当 i >2 时， 就是上面②的情况， 对于 i ，第一个能满足筛除 x 的数  y 必然为 y=p2*p3...*pn（p2可以与p1相等或不等），而且满足条件的 y 有且只有一个。所以不会重复删除。

证明合数肯定会被干掉？ 用归纳法吧。

类比一个模型，比如说我们要找出 n 中2个不同的数的所有组合 { i , j } ，1<=i<=n, 1<=j<=n,

我们会这么写

for(i = 1; i < n; i++)
	for(j = i+1; j <= n; j++)
	{
		/////;
	}

我们取 j=i+1 便能保证组合不会重复。快速筛法大概也是这个道理，不过这里比较难理解，没那么直观。