对质数的判断

来源：互联网发布：java数组去重的方法编辑：程序博客网时间：2024/05/16 14:30

众所周知，判断质数在许多领域都有着应用。而判断质数是一个NP问题，所以这使得RSA足够安全。

但是在许多的题目中我们仍然要用到判断质数。所以编写一个高效的算法就成了问题。

【引入 - 基本方法】

判断质数，最简单的方法就是枚举数字的每一个因子。因为我们知道数的每一个因子都小于这个数，所以最简单的方法就是直接判断：

bool isPrime(int Number){
for (int i=2;i<Number;++i){
if (Number % i == 0){
return true;
}
}
return false;
}

但是我们还可以观察到另一个性质，比如说6，他的因子有1,2,3,6，其中1*6=6，2*3=6。所以我们可以看到一个显而易见的优化，那就是只枚举上述两个式子中较小的数字，也就是1（其实不算），和2。举个例子，4，我们就要枚举到sqrt（4）。所以我们又得到了一个更为高效的程序：

# include <cmath>
bool isPrime(int Number){
for (int i=2;i<=sqrt(Number);++i){
if (Number % i == 0){
return true;
}
}
return false;
}

这个程序的高效其实在于sqrt()将规模大大减小，但是在对付小数据时会因为sqrt()的慢速而拖慢。不过还有一个更加好的优化，注意到这个程序在判断的时候可以不用判断所有的偶数，因此在这里给出一个更为高效的程序：

# include <cmath>
bool isPrime(int Number){
if ((Number & 1) == 0){
return false;
}
for (int i=3;i<=sqrt(Number); i += 2){
if (Number % i == 0){
return true;
}
}
return false;
}

显然这个程序已经足够高效，但是如果调用很多次isPrime()呢？比如说调用1000000（10^7）次isPrime(k)，其中k是一个很大的质数呢？这样的话这个程序的时间复杂度就会达到一个最坏的程度，也就是O(sqrt(Number))。

【承接 - 筛法】

曾有过一个叫埃拉托斯特尼的人，发明了一种判断质数的高效方法。首先，将所有的数假设为质数，接着，将1与0设为合数。接着从2开始，依个递增，对于所有的遇到的质数，将其所有的倍数全部判断为合数。接着这样就能够打出一个质数的表，判断就只需要O(1)的时间！

那么主要的时间，就只需要筛一筛质数了。按照基本的思路，写出一个程序：

# include <cstring>
const int MAXN = 10001;
bool Primes[MAXN];//质数表 
int PrimesSize = 0;//质数表的大小 
void MakePrimeTables(int MaxSize){
if (MaxSize <= PrimesSize){
//无须继续打表，因为已经打过了 
return;
}
else{
memset(Primes,true,sizeof(Primes));
Primes[0] = false;
Primes[1] = false;

int NowPos = 2;
while (NowPos < MaxSize){
if (Primes[NowPos]){
int TimesNumber = NowPos + NowPos;
while (TimesNumber <= MaxSize){
Primes[TimesNumber] = false;
TimesNumber += NowPos;
}
}
}
}
}

但是这个程序的复杂度显然是O(n^2)，比如说6，就会被2和3筛掉。而这就浪费掉了不少时间。如果能够只筛一次的话，那就能够大大优化，只有O(n)！为了好算一些，我们就假定它们是被其最小的质因数筛掉的。而这就引出了一种筛法：线性筛法！

int MAXN = 100001;
int MAXP = 10001;
bool Primes[MAXN];
int PrimeNumber[MAXP];
void GetPrime()    
{    
    memset(Primes,true,sizeof(Primes)); 
    memset(PrimeNumber,0,sizeof(PrimeNumber)); 
    for(int i=2;i<=MAX;i++)    
    {    
        if(Prime[i]) PrimeNumber[PrimeNumberSize++]=i; // 说明i是一个素数
        for(int j=0; j<PrimeNumberSize && i*PrimeNumber[j]<=MAX; j++) // 遍历所有的质因子
        {    
            Primes[i*PrimeNumber[j]]=false;    
            if(i%PrimeNumber[j]==0) break; // 如果i能够整除pri[j]那么i*pri[j+1]就一定被pri[j]数整除。
        }    
    }    
}

【补充 - 费马小定理性筛法】

费马小定理，是数论中一个非常重要的算法。其重要程度使其可以与孙子定理，威尔逊定理，欧拉定理这四大定理并称。其的描述非常简单，即假设p是质数，且a,p互质，则下列同余式成立：

a(p-1)≡1（mod p）

这个定理很简洁，但却也很实用，比如，卡米克尔法，就是一种快速判定质数的方法，随机给定一个数，都有75%的可能性判断正确。而比如说我们用随机数判断20次，那么正确的的概率就升到到了1-（0.25）^20=0.99999999999909050529822707176208左右。也就是说几乎不可能错了。而在《骗分导论》中还介绍到了一些可以用来判定的数字，可以再long long int或int64范围内100%判定成功。

不过其实程序我也不是很会写，所以就拿了别人的一段程序以作参考。

//****************************************************************
// Miller_Rabin 算法进行素数测试
//速度快，而且可以判断 <2^63的数
//****************************************************************
const int S = 20; //随机算法判定次数，S越大，判错概率越小


//计算 (a*b)%c.   a,b都是long long的数，直接相乘可能溢出的
//  a,b,c <2^63
long long mult_mod(long long a, long long b, long long c)
{
    a %= c;
    b %= c;
    long long ret = 0;

    while(b)
    {
        if(b & 1)
        {
            ret += a;
            ret %= c;
        }

        a <<= 1;

        if(a >= c)a %= c;

        b >>= 1;
    }

    return ret;
}



//计算  x^n %c
long long pow_mod(long long x, long long n, long long mod) //x^n%c
{
//Fast-Pow
    if(n == 1)return x % mod;

    x %= mod;
    long long tmp = x;
    long long ret = 1;

    while(n)
    {
        if(n & 1) ret = mult_mod(ret, tmp, mod);

        tmp = mult_mod(tmp, tmp, mod);
        n >>= 1;
    }

    return ret;
}





//以a为基,n-1=x*2^t      a^(n-1)=1(mod n)  验证n是不是合数
//一定是合数返回true,不一定返回false
//利用费尔马小定理：
bool check(long long a, long long n, long long x, long long t)
{
/*a^x%n*/ 
    long long ret = pow_mod(a, x, n);
    long long last = ret;

    for(int i = 1; i <= t; i++)
    {
    /*ret*ret%n*/ 
        ret = mult_mod(ret, ret, n);

        if(ret == 1 && last != 1 && last != n - 1) return true; //合数

        last = ret;
    }

    if(ret != 1) return true;

    return false;
}

// Miller_Rabin()算法素数判定
//是素数返回true.(可能是伪素数，但概率极小)
//合数返回false;

bool Miller_Rabin(long long n)
{
/*防止误判*/

    if(n < 2)return false;

    if(n == 2)return true;

/*提高效率的特判*/ 
    if((n & 1) == 0) return false; //偶数

    long long x = n - 1;
    long long t = 0;

    while((x & 1) == 0)
    {
        x >>= 1;
        t++;
    }

    for(int i = 0; i < S; i++)
    {
    /*
下面这里是以随机数来测试质数
但是，可以直接测试某一些数，就直接100%零错率做到又快又好
测试，但仍然要排除一些强伪素数 
*/ 
        long long a = rand() % (n - 1) + 1;

        if(check(a, n, x, t))
            return false;//合数
    }

    return true;
}

这里用到了随机数，所以可能有一点不够稳定，而这个算法的时间复杂度大概是O(log2n)，运用了快速幂的优化之后相当不错。

实际上，只需要一些小范围的素数，如2,3,5,7之类，就可以使得判断正确的范围达到int的上限。而且时间复杂度是O(log2n)。这显然是一个非常之好的复杂度，就算是判断上到long long的质数也几乎是常数级的。

0 0