筛法求大量素数

一、朴素筛法求n以内的所有素数

原理：如果一个数是合数，那么我们可以用它的因子（不包括1与它自身）把这个数筛掉。

思路：

         bool f[maxn+100];
         f[i]==1表示数字i不是质数，f[i]==0表示数字i是质数 
         int p[maxn];
         p[0]表示素数的个数，p[i]记录第i个素数的值  

 

         我们从2开始往后进行扫描，假设当前扫描到数字 i ，有两种情况：

          1、f[i]==1，即表示数字 i 为合数，不作处理。

          2、f[i]==0，即表示数字 i 为质数。这是为什么呢？根据上述原理，若存在数字 j （1<j<i ） 为 i 的因子，那么在前面枚举到 j 时，我们会把 j 的所有倍数都标记为合数，也就是说，f[i]==0 就表示在小于 i 的数中，不存在 i 的因子 j ，数字 i 当然也就是质数了。

                ok，接下来还有两步操作： 

                首先，我们要将素数 i 存储下来；

                其次，将素数 i 的所有倍数都标记为合数。          

代码：

 

f[0]=f[1]=1;
  for(i=2;i<=n;i++)
    if(f[i]==0)
      {
        p[++p[0]]=i;
        for(j=i+i;j<=n;j+=i)f[j]=1;
      }

 

 

 

二、线性筛法求n以内的素数

 

 

 

原理：每个合数都有一个最小的质因数，每个合数只被它的最小质因数筛去。

思路：分析上述的朴素筛法，我们可以发现一个数实际上可能被多次筛选，比如数字12，被数字2、3筛选两次，这就造成效率上的               浪费，有没有什么办法可以使得每个数字都只被筛选一次，从而使得此筛法成为线性的呢？

            我们可以将朴素筛法进行改进，使得每个数字都只被它的最小质因数筛去。

            （状态定义与上面的一致）

            假设当前枚举到数字 i ，接下来有两步处理：

            1、若f[i]==0，即数字 i 为质数，那么将数字 i 假如素数表p。

            2、此时的话，素数表 p 内存储的都是小于等于 i 的素数。假设第 j  个素数为 p[j] ，则 k =p[j]*i，k的最小质因数即为 p[j]，我们就用 p[j] 筛去数字 k。

                好了，这里还要讲一下的是，下列代码中的这一句：

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

                为什么要加这一句呢？若 i % p[j]==0 表示 i 是 p[j] 的倍数，则 k=p[j+1]*i也是 p[j] 倍数，并且可以将其变形得到这样的一个式                 子：k = p[j+1]*i = p[j+1] * p[j] * x。

                我们的方法是只用一个数的最小质因数筛去它，由此，p[j] 之后的素数就没有再枚举的必要了，而数字p[j] * i 会在之后枚举                   到数字 p[j+1] * x 时，被  p[j] 筛掉。  

代码：

 

int i,j,k,n;
f[0]=f[1]=1;
p[0]=0;
for(i=2;i<=n;i++)
  {
    if(!f[i])p[++p[0]]=i;
    for(j=1;j<=p[0] && i*p[j]<=n;j++)
      {
        f[i*p[j]]=1;
        if(i%p[j]==0)break;
      }
  } 

 

 

 

 

 

 

看了上述的线性筛法，其实还能发现线性求解 n 以内每个数的最小质因数的解法，至于怎么做，这里就不再多说了。不知道的话，可以在下方留言。

 

三、空间折半优化

原理：所有的偶数（除 2 以外）都为合数。

思路：在前面的状态定义中，我们都是直接存储数字 i ，用 f[i] 来记录数字 i 是否为质数。根据上述原理，我们可以只记录奇数，而               不记录偶数，这样的话，对于给定的范围 n ，我们原本需要定义长度为 n 的数组，现在仅仅只用定义长度为 n/2 的数组即可。

            f[i] 记录数字2*i+1是否为质数，其余的处理与上述的筛法类似。

加入空间优化之后的代码：

 

 

int i,j,k,n,maxn;
  maxn=n/2;
  p[++p[0]]=2;
  for(i=1;i<=maxn;i++)
    {
      k=2*i+1;  
      if(!f[i])p[++p[0]]=k;
      for(j=2;j<=p[0] && k*p[j]/2<=maxn;j++)
        {
          f[k*p[j]/2]=1;
          if(k%p[j]==0)break;
        }
    }

 

 

 

 

 

 

四、区间求素数

 

   （以下摘自csdn上的一篇转载文章：http://blog.csdn.net/byijie/article/details/8145391，原作者我并不知道，万分抱歉）

 

简述：有的时候，我们需要知道某个特定区间的素数(区间大小较小，但数可能很大)。
那么数组就开不下，这时候我们仍然可以使用筛法，只是所有的下标都进行了偏移。
大家理解下面这段代码可以先用普通筛法写，然后数组下标集体移动即可。

const int maxn = 100000;

int PrimeList[maxn];
int PrimeNum;
bool IsNotPrime[maxn]; // IsNotPrime[i] = 1表示i + L这个数是素数.

void SegmentPrime(int L, int U)
{ // 求区间[L, U]中的素数.
int i, j;
int SU = sqrt(1.0 * U);
int d = U - L + 1;
for (i = 0; i < d; i++) IsNotPrime[i] = 0; // 一开始全是素数.
for (i = (L % 2 != 0); i < d; i += 2) IsNotPrime[i] = 1; // 把偶数的直接去掉.
for (i = 3; i <= SU; i += 2)
{
  if (i > L && IsNotPrime[i - L]) continue; // IsNotPrime[i - L] == 1说明i不是素数.
  j = (L / i) * i; // j为i的倍数，且最接近L的数.
  if (j < L) j += i;
if (j == i) j += i; // i为素数，j = i说明j也是素数，所以直接 + i.
j = j - L;
for (; j < d; j += i) IsNotPrime[j] = 1; // 说明j不是素数(IsNotPrime[j - L] = 1).
}
if (L <= 1) IsNotPrime[1 - L] = 1;
if (L <= 2) IsNotPrime[2 - L] = 0;
PrimeNum = 0;
for (i = 0; i < d; i++) if (!IsNotPrime[i]) PrimeList[PrimeNum++] = i + L;
}