poj2635The Embarrassed Cryptographer（同余模+素数筛选+高精度求模）

The Embarrassed Cryptographer

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 14852		Accepted: 4071

Description

The young and very promising cryptographer Odd Even has implemented the security module of a large system with thousands of users, which is now in use in his company. The cryptographic keys are created from the product of two primes, and are believed to be secure because there is no known method for factoring such a product effectively. 
What Odd Even did not think of, was that both factors in a key should be large, not just their product. It is now possible that some of the users of the system have weak keys. In a desperate attempt not to be fired, Odd Even secretly goes through all the users keys, to check if they are strong enough. He uses his very poweful Atari, and is especially careful when checking his boss' key.

Input

The input consists of no more than 20 test cases. Each test case is a line with the integers 4 <= K <= 10 ¹⁰⁰ and 2 <= L <= 10 ⁶. K is the key itself, a product of two primes. L is the wanted minimum size of the factors in the key. The input set is terminated by a case where K = 0 and L = 0.

Output

For each number K, if one of its factors are strictly less than the required L, your program should output "BAD p", where p is the smallest factor in K. Otherwise, it should output "GOOD". Cases should be separated by a line-break.

Sample Input

143 10
143 20
667 20
667 30
2573 30
2573 40
0 0

Sample Output

GOOD
BAD 11
GOOD
BAD 23
GOOD
BAD 31

Source

Nordic 2005

题意：求出两素数乘积为k，如果比l大，则输出bad+最小的素数，如果比l小，输出good

10的100次方数够大了，如果每次都以十进制取模素数，那么肯定超时，因此高精度求模，换成千进制，算式为：

r=(r*1000+kt[i])%q;，其中r为进位，kt[i]为原十进制位值，q为取模数

代码

int r=0;
    for(int i=len-1; i>=0; i--)
    {
        r=(r*1000+kt[i])%q;
    }

然后就是素数打表，这里要求打出1e6的素数，注意是素数值最大要超过1e6

不用素数筛选也可以~

int get_prim()
{
    int cnt=0;
    prime[cnt++]=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[cnt++]=i;
    }
}

筛选法：

int get_prim()
{
    int cnt=0;
    prime[cnt++]=2;
    for(int i=3; i<=N; i+=2) //奇偶法
    {
        bool flag=true;

        if(!vist[i])

        for(int j=i+i; j<=N; j+=i) //根号法+递归法
            
            
                vist[j]=0;
   
        if(vist[i])
            prime[cnt++]=i;
    }
}

然后就是进制转换了，十进制转千进制，在这里倒序更好下一步处理：

int get_kt(char *K,int lenK)
{
    for(int i=0;i<lenK;i++)  //把K转换为千进制Kt，其中Kt局部顺序，全局倒序
        {                      //如K=1234567=[  1][234][567] ，则Kt=[567][234][1  ]
            int pKt=(lenK+2-i)/3-1;
            kt[pKt]=kt[pKt]*10+(K[i]-'0');
        }
}

代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <iostream>
using namespace std;
#define N 1000100
int prime[N];
int kt[11000];

int get_prim()
{
    int cnt=0;
    prime[cnt++]=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[cnt++]=i;
    }
}

int get_kt(char *K,int lenK)
{
    for(int i=0;i<lenK;i++)  //把K转换为千进制Kt，其中Kt局部顺序，全局倒序
        {                      //如K=1234567=[  1][234][567] ，则Kt=[567][234][1  ]
            int pKt=(lenK+2-i)/3-1;
            kt[pKt]=kt[pKt]*10+(K[i]-'0');
        }
}
int get_mod(int q,int len)
{
    int r=0;
    for(int i=len-1; i>=0; i--)
    {
        r=(r*1000+kt[i])%q;
    }
    if(!r)
        return 0;///整除
    return 1;
}

int main()
{
    get_prim();
    int L;
    char K[10000];
    while(cin>>K>>L && L)
    {
        memset(kt,0,sizeof(kt));
        int len=strlen(K);
        get_kt(K,len);
        int len1=(len+2)/3;
        /*for(int i=0;i<len;i++)
        {
            cout<<"--->"<<kt[i]<<endl;
        }*/
        int flag=1;
        int pMin=0; 
        while(prime[pMin]<L)  
        {
            if(!get_mod(prime[pMin],len1))
            {
                flag=0;
                cout<<"BAD "<<prime[pMin]<<endl;
                break;
            }
            pMin++;
        }
        if(flag)
            cout<<"GOOD"<<endl;
    }
    return 0;
}