两次筛素数：Prime Distance

 总结：

应用场景： 

给你一个 L 和 R 需要筛选出其中的素数时，可以使用线性筛的方式。

但是线性筛的时候需要一个数组用于记录素数， 用另一个数组用于记录哪些合数已经被筛掉了。

这时，如果R很大怎么办。开不了这么大的数组用于统计是否被筛掉了。

这时，如果L~R的范围差（R - L的值）如果不是很大，可以使用数组存储的时候。

或者就是求一个很大的数n的1~n中素数的时候。（因为1~n的素数个数大概为n / ln (n) ,n == 1e9的时候，大概48254942个，可以用数组存储）

这个时候就可以用到两次筛素数的方式了。

方式：

由于任何一个合数C，都会有至少一个 小于等于 sqrt(C)的质数,

所以我们可以先通过线性筛，将1 ~ sqrt(R)中的素数筛出来。

然后在通过这些被筛选出的素数，去筛掉大于 sqrt(R)的合数。

最后剩下的就是L ~ R中的素数了。

题目链接：http://poj.org/problem?id=2689

题目：

思路：

两次筛素数，由于R-L的值小，而R的值很大。所以先使用线性筛预处理出，大概1e5 ~ 1e6的素数

然后在通过这些素数筛掉大于L小于R的合数。

当然还要注意一些当L等于1的时候，由于这两个阶段都不会考虑到1这个值，所以1进行特判。

最后注意当int为2147483647之后，值会溢出，需要考虑到这一点。

代码实现：

# include <iostream>
# include <cstring>
using namespace std;

const int N = 1e6 + 10;

int prim[N],cnt = 1;
bool choose[N];
bool book[N];  // 标记
int a[N];

int main()
{
    for(int i = 2 ; i <= 1e6 ; i ++)
    {
        if(!choose[i])
        {
            prim[cnt++] = i;
        }
        for(int j = 1 ; prim[j] <= 1e6 / i ; j++)
        {
            choose[i * prim[j] ] = true;
            if(i % prim[j] == 0)
            {
                break;
            }
        }
    }
    int l,r;
    while(scanf("%d%d",&l,&r)==2)
    {
        memset(book,false,sizeof book);
        if(l == 1)
        {
            book[0] = true;
        }

        for(int i = 1 ; i <= cnt ; i++)
        {
            if(prim[i]  > r / prim[i])
            {
                break;
            }
            for(int j = max(2,l / prim[i]); j <= r / prim[i] ; j++)
            {
                if(j * prim[i] >= l)
                {
                    book[j * prim[i] - l] = true;
                }
            }
        }

       int total = 0;
       // 如果r为int的最大值，则i + 1 , 变为了int的最小值
        for(long long i = l ; i <= r ; i++)
        {
            if(!book[i - l])
            {
                a[++total] = i;
            }
        }

        int maxpre = -1;
        int maxhost = -1;

        int minpre = -1;
        int minhost = -1;

        int max1 = -0x3f3f3f3f;
        int min1 = 0x3f3f3f3f;

        if(total < 2)
        {
            printf("There are no adjacent primes.\n");
        }
        else
        {
            for(int i = 2 ; i <= total ; i++)
            {

                if(a[i] - a[i - 1] > max1)
                {
                    max1 = a[i] - a[i - 1];
                    maxpre = a[i - 1];
                    maxhost = a[i];
                }
                if(a[i] - a[i - 1] < min1)
                {
                    min1 = a[i] - a[i - 1];
                    minpre = a[i - 1];
                    minhost = a[i];
                }
            }
            printf("%d,%d are closest, %d,%d are most distant.\n",minpre,minhost,maxpre,maxhost);
        }
    }
    return 0;
}