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;
}