UVA10140 Prime Distance

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.

Input	Output
2 17 14 17	2,3 are closest, 7,11 are most distant. There are no adjacent primes.

题目大意

给定两个正整数 l,r，求 [l,r] 间 相邻 的两个差最大的质数和 相邻 的两个差最小的质数。如果区间内质数个数 ≤1，输出 There are no adjacent primes.。

求区间内质数模板题，可以发现虽然l，r小于1e9很大，但是判断每个数是不是质数时循环的除数永远<=sqrt（x），且均为质数，故我们可以先预处理sqrt（1e9）<50000，但筛去lr间所有合数，因为r-l<1e6很小，所以我们可以将数据转化为1~1e6之间

具体细节见代码

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#define int long long//！！！！！！！！ 

using namespace std;
//求int范围一个区间内的所有质数 ，区间长度最大为1e6 
typedef long long ll;
const int N = 1e6 + 5;
int prime[N], vis[N], a[N];
int tot, l, r, cnt;

void judge()
{//因为int最大值开根号后小于50000，并且每个数的质因子都<=sqrt(x) 
//所以我们先预处理一下50000以内的质数，然后用他们去筛掉int内所有合数 
	for(int i = 2; i <= 50000; i++)
	{
		if(!vis[i])
			prime[++tot] = i;
		for(int j = 1; j <= tot && (i * prime[j]) < 50000; j++)
		{
			vis[i * prime[j]] = 1;
			if(i % prime[j] == 0)
				break;
		}
	}
}

signed main()
{
	judge();
	while(~scanf("%lld%lld", &l, &r))
	{
		memset(vis, 0, sizeof(vis));
		memset(a, 0, sizeof(a));
		if(l == 1)
			l = 2;//因为l=1时的判断满足条件但1并不是质数，所以可以忽略1 
		for(int i = 1; i <= tot; i++)//将[l,r]转换成[0,r-l] 
			for(int j = (l / prime[i]); j * prime[i] <= r; j++)
				if(j * prime[i] >= l && j > 1)//质数>1的倍数才是合数，j=1会把质数误判 
					vis[j * prime[i] - l] = 1;
		cnt = 0;//对于每个质数，即用埃氏筛的思想去掉l，r之间的所有合数 
		for(int i = l; i <= r; i++)
			if(!vis[i - l])
				a[++cnt] = i;	
		if(cnt < 2)
			printf("There are no adjacent primes.\n");
		else
		{
			int minn = 0x7fffffff, minl, minr, maxn = 0, maxl, maxr;
			for(int i = 2; i <= cnt; i++)
			{
				if(a[i] - a[i - 1] < minn)
				{
					minn = a[i] - a[i - 1];
					minl = a[i - 1], minr = a[i];
				}
				if(a[i] - a[i - 1] > maxn)
				{
					maxn = a[i] - a[i - 1];
					maxl = a[i - 1], maxr = a[i];
				}
			}
			printf("%lld,%lld are closest, %lld,%lld are most distant.\n", minl, minr, maxl, maxr);
		}
	}
return 0;
}