poj2635

题目有难度。好几个小时，不断优化。题目意思很明确就是给定一个数，该数是两个素数的乘积。判断其中较小的素数是否比题目给定的最小素数小。

若小于题目给定的素数则输出“BAD 最小素数”，否则输出“GOOD ”。

那么思路很明确了：就是枚举题目2——题目给定的素数之间的所有素数，看是否有素数能够被该数整除。若能够则输出“BAD 该素数”，否则输出GOOD

本题涉及的知识点有：筛法求素数（高效算法）、同余模定理+高精度、进制转换

一、筛法求素数：

在我的博客中有详细介绍筛法求素数。这里给出我所遇到的最有效算法（第二个函数）： （包含我先前的认为最有效的算法，其实不是（第一个函数））

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<ctime>
#define Max 110
#define Maxx 10000010
using namespace std;
int prime[Maxx];
bool flag[Maxx];
void Get_prime(int n){
clock_t start, finish; //建立对象
double totaltime;
start = clock(); //clock():Current time of CPU，当前的时间
int i,j,pivot=0;
for(i=3;i<=n;i+=2)
prime[pivot++]=i;
memset(flag,1,pivot);
for(i=0;prime[i]<=int(sqrt(double(n)));i++)
if(flag[i]){
for(j=i*((i<<1)+6)+3;j<pivot;j++)
if(prime[j]%prime[i]==0)
flag[j]=0;
}
/*printf("2 ");
for(i=0;i<pivot;i++)
if(flag[i])
printf("%d ",prime[i]);
printf("\n");*/
finish=clock();//现在的时间
totaltime=(double)(finish-start)/CLOCKS_PER_SEC; //现在的时间-设置的初始时间=程序运行的时间，转化为s
printf("Runtime is: %lf s\n",totaltime);
//num=pivot;
}
void PrimeTable(int n)
{
clock_t start, finish; //建立对象
double totaltime;
start = clock(); //clock():Current time of CPU，当前的时间
int pNum=0;
prime[pNum++]=2;
for(int i=3;i<=n;i+=2)  //奇偶法
{
bool flag=true;
for(int j=0;prime[j]*prime[j]<=i;j++)  //根号法+递归法
if(!(i%prime[j]))
{
flag=false;
break;
}
if(flag)
prime[pNum++]=i;
}
printf("%d\n",pNum);
/*for(int i=0;i<pNum;i++)
printf("%d ",prime[i]);
printf("\n");*/
finish=clock();//现在的时间
totaltime=(double)(finish-start)/CLOCKS_PER_SEC; //现在的时间-设置的初始时间=程序运行的时间，转化为s
printf("Runtime is: %lf s\n",totaltime);
//num=pNum;
//return;
}
int main(){
Get_prime(5000000);
PrimeTable(1000000);

return 0;
}

就是因为筛法不够高效，结果总是TLE。

二、同余模定理+高精度

这里，我们姑且可以把这看作一个定理：

124%3=?

第一步: point=0 （point*10+1)%3=1

第二步: point=1 （point*10+2)%3=0

第三部: point=0 （point*10+4)%3=1

结束

这样可以利用整形数组保存高精度数据。然后依据上面的步骤计算取模，这样需要计算len(len为数据位数）次，当然如果把十进制改为白进制、千进制则依次需len/2、len/3次运算。题目要求数据量可以到达L=10W，K=10^100，可以计算在L=10W范围内有78498个素数，而K最大为100位，那么如果用十进制取模的话最坏时间复杂度为需要

78498*100/1000MS，（1MS大约执行1000条语句）肯定会超时。而用1000进则需要78498*33/1000MS，在可允许的范围内。用10000进制原则上要更快，只是要注意精度问题。

下面是代码： 440K+1250MS

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#define Max 110 // 最多100位
#define Maxx 78500 // 素数有78498个
int prime[Maxx];
char record[Max];
int tran[Max];
int L,len,num,tlen;
bool Is_right(int n){ //求模
int point=0;
for(int i=tlen;i>=0;i--)
point=(tran[i]+1000*point)%n;
if(point==0)
return true;
return false;
}
void PrimeTable(int n)   // 筛法打表
{
int pNum=0;
prime[pNum++]=2;
for(int i=3;i<=n;i+=2)  //奇偶法
{
bool flag=true;
for(int j=0;prime[j]*prime[j]<=i;j++)  //根号法+递归法
if(!(i%prime[j]))
{
flag=false;
break;
}
if(flag)
prime[pNum++]=i;
}
num=pNum;
return;
}
int main(){
PrimeTable(1000000);
while(true){
scanf("%s",record);
len=strlen(record);
scanf("%d",&L);
if(L==0)
break;
int pivot=1,index=0,point=1;
tran[0]=0; // 进制转换
for(int i=len-1;i>=0;i--){
tran[index]+=(point*(record[i]-'0'));
point*=10;
if(pivot==3){
pivot=1;
index++;
tran[index]=0;
point=1;
}
else
pivot++;
}
if(pivot==1)
tlen=index-1;
else
tlen=index;
int trag=true;
for(int i=0;i<num;i++){ // 循环枚举比L小的素数
if(prime[i]>=L)
break; // 注意此处不能直接判定就是GOOD，因为可能所有的素数都比该数小
if(Is_right(prime[i])){
printf("BAD %d\n",prime[i]);
trag=false;
break;
}
}
if(trag)
printf("GOOD\n");
getchar();
}
return 0;
}