Prime Distance（筛选法求素数 ）

Description

The branch of mathematics called number theory is about properties of numbers. One of the areas that has captured the interest of number theoreticians for thousands of years is the question of primality. A prime number is a number that is has no proper factors (it is only evenly divisible by 1 and itself). The first prime numbers are 2,3,5,7 but they quickly become less frequent. One of the interesting questions is how dense they are in various ranges. Adjacent primes are two numbers that are both primes, but there are no other prime numbers between the adjacent primes. For example, 2,3 are the only adjacent primes that are also adjacent numbers. 
Your program is given 2 numbers: L and U (1<=L< U<=2,147,483,647), and you are to find the two adjacent primes C1 and C2 (L<=C1< C2<=U) that are closest (i.e. C2-C1 is the minimum). If there are other pairs that are the same distance apart, use the first pair. You are also to find the two adjacent primes D1 and D2 (L<=D1< D2<=U) where D1 and D2 are as distant from each other as possible (again choosing the first pair if there is a tie).

Input

Each line of input will contain two positive integers, L and U, with L < U. The difference between L and U will not exceed 1,000,000.

Output

For each L and U, the output will either be the statement that there are no adjacent primes (because there are less than two primes between the two given numbers) or a line giving the two pairs of adjacent primes.

Sample Input

2 17
14 17

Sample Output

2,3 are closest, 7,11 are most distant.
There are no adjacent primes.

题目大意：

给出两个数L和U，求出这两个数之间的所有相邻素数中分别相距最近和最远的两个素数（如果有多组，只需输出第一组）。

解题思路：

L和U的数值比较大，需要查找的素数也比较多，因此应该用筛选法求素数，先筛选出47000内的素数，再筛选2147483647内的素数。

代码如下：

#include<stdio.h>
#include<string.h>
//数组prime标记2到47000内的非素数，数组p2标记L到U内的非素数
bool prime[50000],p2[1001000];
//数组p1储存2到47000内的素数，count记录该区间内素数的个数
__int64 p1[10000],count=0;
//筛选法求出47000内的素数
void getprime()
{
    __int64 i,j;
    //初始化标记数组prime
    memset(prime,0,sizeof(prime));
    //筛选法核心
    for(i=2;i<=47000;i++)
	{
		if(prime[i]==0)
		{
		    //数组p1记录2到47000内的素数素数
            p1[count++]=i;
            for(j=i*i;j<=47000;j+=i)
                prime[j]=1;
        }
	}
}
int main()
{
    __int64 i,j,L,U;
    getprime();
    while(scanf("%I64d%I64d",&L,&U)!=EOF)
	{
        memset(p2,0,sizeof(p2));
        //包含1的区间作特殊处理，1即不是素数也不是合数
        if(L==1)
            L=2;
        //筛选指定区间L到U的素数，
        for(i=0;i<count&&p1[i]*p1[i]<=U;i++)
        {
            if(L<=p1[i])
            {
                for(j=p1[i]*2;j<=U;j+=p1[i])
                    p2[j-L]=1;
            }
            else
            {
                for(j=p1[i]*(L/p1[i]+(L%p1[i]>0));j<=U;j+=p1[i])
                    p2[j-L]=1;
            }
        }
        __int64 ans[1000000],sum=0,dis=U-L+1;
        //储存区间L到U的素数
        for(i=0;i<dis;i++)
        {
            if(p2[i]==0)
				ans[sum++]=i+L;
        }
        //当区间的素数小于两个时，就不会存在相邻的
		if(sum<2)
		{
			printf("There are no adjacent primes.\n");
		}
		else
		{
			__int64 min=ans[1]-ans[0],max=ans[1]-ans[0],r1=1,r2=1;
			for(i=2;i<sum;i++)
			{
				if(min>ans[i]-ans[i-1])
				{
					min=ans[i]-ans[i-1];
					r1=i;
				}
				if(max<ans[i]-ans[i-1])
				{
					max=ans[i]-ans[i-1];
					r2=i;
				}
			}
			printf("%I64d,%I64d are closest, %I64d,%I64d are most distant.\n",ans[r1-1],ans[r1],ans[r2-1],ans[r2]);
		}
    }
    return 0;
}