素数判断 Miller_Rabin算法-hoj1356和51nod1186质数检测V2

源博客

这么神奇的代码就能过51nod1186.。。

[java]  view plain  copy

1. import java.util.Scanner;  
2. import java.math.*;  
3.   
4. public class Main {  
5.     public static void main(String[] args) {  
6.         Scanner cin = new Scanner(System.in);  
7.         BigInteger x;  
8.             x=cin.nextBigInteger();  
9.             if(x.isProbablePrime(1))  
10.                 System.out.println("Yes");  
11.             else  
12.                 System.out.println("No");  
13.     }  
14.   
15. }  

 

 

一、 先介绍几个定理

  费马小定理，二次探测定理

参考：http://baike.baidu.com/，http://blog.csdn.net/iyundi/article/details/9955353

1、费马小定理

著名的费马小定理为素数判定提供了一个有力的工具.

费马小定理:如果p是一个素数,且(0<a<p),则

证明是容易的.

2、二次探测定理

如果p是素数，x是小于p的正整数，且，那么要么x=1，要么x=p-1。

这是显然的，因为相当于p能整除，也即p能整除(x+1)(x-1)。

由于p是素数，那么只可能是x-1能被p整除(此时x=1) 或 x+1能被p整除(此时x=p-1)。

二 Miller_Rabin定理分析

由费马小定理我们知道，如果p是素数，那么a的p-1次方mod p =1.这个定理成立，那么他的逆否命题肯定成立，也就是凡是a^(p-1)Mod p != 1的，那么p一定是合数，就是不是素数，但是这有一个条件，那就是a和p得互质。

逆否命题成立了，但是人们更关心的是逆命题，因为这样可以判断一个数是否是素数，如果逆命题成立，那么就可以通过a^(p-1)Mod p = 1来判断p是素数了。但是想象是美好的，现实是残酷的。

1819年有人发现了Fermat小定理逆命题的第一个反例：虽然2的340次方除以341余1，但341=11*31，却不是素数。后来，人们又发现了561, 645, 1105等数都表明a=2时Fermat小定理的逆命题不成立。人们把所有能整除2^(n-1)-1的合数n叫做伪素数(pseudoprime)。

不满足的n一定不是素数；如果满足的话则多半是素数。这样，一个比试除法效率更高的素性判断方法出现了：制作一张伪素数表，记录某个范围内的所有伪素数，那么所有满足且不在伪素数表中的n就是素数。之所以这种方法更快，是因为我们可以使用二分法快速计算的值(快速幂)。

然而不借助伪素数表的时候,算法出错的概率太高,需要改进.

1、Fermat素性测试

我们刚才只考虑了a=2的情况。一个合数可能在a=2时通过了测试，但a=3时的计算结果却排除了素数的可能。于是，人们扩展了伪素数的定义，称满足a^(n-1) mod n = 1的合数n叫做以a为底的伪素数(pseudoprime to base a)。

随机选择若干个小于待测数的正整数作为底数a进行若干次测试，只要有一次没有通过测试就立即把这个数扔回合数的世界。这就是Fermat素性测试。

2、Carmichael数

费马小定理毕竟只是素数判定的一个必要条件.满足费马小定理条件的整数n未必全是素数.有些合数也满足费马小定理的条件.这些合数被称作Carmichael数,前3个Carmichael数是561,1105,1729. Carmichael数是非常少的.在1~100000000范围内的整数中,只有255个Carmichael数.

3、二次探测来检验一个数是否是素数

费马小定理的前提是a和n互质。当n本身就是素数的时候如果a<n那么a和n始终互素；但n不是素数时a和n不互素的话不能用费马小定理。也就是说，Carmichael数需要排除a和n不互素的情况.
二次探测：

如果p是素数，x是小于p的正整数，且，那么要么x=1，要么x=p-1。

这是显然的，因为相当于p能整除，也即p能整除(x+1)(x-1)。

由于p是素数，那么只可能是x-1能被p整除(此时x=1) 或 x+1能被p整除(此时x=p-1)。

我们下面来演示一下上面的定理如何应用在Fermat素性测试上。前面说过341可以通过以2为底的Fermat测试，因为2^340 mod 341=1。如果341真是素数的话，那么根据二次探测定理有2^170mod 341只可能是1或340；当算得2^170 mod 341确实等于1时，我们可以继续查看2^85除以341的结果。我们发现，2^85 mod 341=32，这一结果摘掉了341头上的素数皇冠

这就是Miller-Rabin素性测试的方法。不断地提取指数n-1中的因子2，把n-1表示成（其中d是一个奇数）。那么我们需要计算的东西就变成了除以n的余数。于是，要么等于1，要么等于n-1。如果等于1，定理继续适用于，这样不断开方开下去，直到对于某个i满足或者最后指数中的2用完了得到的。这样，Fermat小定理加强为如下形式：

尽可能提取因子2，把n-1表示成，如果n是一个素数，那么或者，或者存在某个i使得 ( 0<=i<r ) （注意i可以等于0，这就把的情况统一到后面去了）

      问题已经很清楚了，只需要判断所有的二次探测满足条件就可以判定一个数极有可能是素数（不能肯定，因为逆命题不成立，前面已经说明过了）。那算法如何实现呢？

      根据二次探测，我们将n-1化简为d*2^r，从a^d次方算起mod n是否是1或者n-1，如果不是，直接判断不是素数。如果是，那么判断a^(d*2)也就是a^(d*2^1),刚好符合二次探测定理。也和上面2^340,2^170,2^85。。。一样，只不过是从小向大计算。这样通过了所有以2为底的，可能是素数，可能性不是很高，如果能通过以3为底，以5为底。。。次数越多，得到是素数的概率越高。一般随机10个a，就能达到99.99%的正确率。

三、C++实现，题目hoj1356

[cpp]  view plain  copy

1. /*对应hoj 1356 Prime Judge*/    
2. #include <cstdio>     
3. #define MT 5     
4. using namespace std;    
5. typedef long long ll;    
6. int prime[] = {2, 3, 7, 61, 24251};    
7.     
8. inline ll mulmod(ll a, ll b, ll k) {//*标出了核心语句     
9.   //  a %= k;     
10.   //  b %= k;     
11.     if (b < 0) {///将b变为正的     
12.         a = -a;    
13.         b = -b;    
14.     }    
15.     ll re = 0, temp = a;    
16.     ///re为最终结果,temp保持循环.re需要temp的时候,就加一下,否则temp继续累乘     
17.     while (b) {    
18.         if (b & 1) re += temp;///二进制思想,需要即加*     
19.     //  re %= k;     
20.         b >>= 1;///下一位等待检测**     
21.         temp <<= 1;///temp一直累乘***     
22.      // temp %= k;     
23.     }    
24.     return re%k;*/    
25. /*实际上呢,用以上的函数在hoj 1356是会TLE的(mod太多次了...)~应该用下面的方法...*/    
26.     return (a*b)%k;//-_-b     
27.  }    
28. //此时不需要再模,于是只剩下核心语句~快速幂和快速积都是二进制思想,核心是一样的     
29. inline ll powermod(ll a, ll b, ll k) {    
30.     ll re = 1, temp = a;    
31.     while (b) {    
32.         if (b & 1) re = mulmod(re, temp, k);//只是把"加"入答案变为"乘"入答案     
33.         temp = mulmod(temp, temp, k);    
34.         b >>= 1;    
35.     }    
36.     return re;    
37. }    
38.     
39. int TwiceDetect(ll a, ll b, ll k) {    
40.     int t = 0;    
41.     ll x, y;    
42.     while ((b & 1) == 0) {    
43.         b >>= 1;    
44.         t++;    
45.     }    
46.     /// b = d * 2^t;   b = d;     
47.     y = x = powermod(a, b, k);/// x = y = a^d % n     
48.     ///二次探测定理是反向递归的,当然也可以用如下的正向迭代法去测试     
49.     while (t--) {    
50.         y = mulmod(x, x, k);    
51.         if (y == 1 && x != 1 && x != k - 1)///注意y!=1的时候是不做判断的,即对应     
52.             return 0;///递归时在某一环节x==p-1的情况,对此x开方则无意义,但是迭代的话不能break,只能ignore并继续.     
53.         x = y;///继续向高次迭代,那么至少最后一次应该是等于1的(Fermat小定理)     
54.     }    
55.     return y;    
56. }    
57.     
58. bool Miller_Rabin(ll n) {    
59.     int i;    
60.     ll tmp;    
61.     for (i = 0; i < MT; i++) {    
62.         tmp = prime[i];    
63.         if (n == prime[i]) return true;    
64.         if (TwiceDetect(tmp, n - 1, n) != 1)    
65.             break;    
66.     }    
67.     return (i == MT);    
68. }    
69.     
70. int main() {    
71.     ll n;    
72.     while (scanf("%lld", &n) == 1) {    
73.         if ((n > 1) && Miller_Rabin(n)) {    
74.             printf("YES\n");    
75.         } else {    
76.             printf("NO\n");    
77.         }    
78.     }    
79.     return 0;    
80. }   

[cpp]  view plain  copy

1.    

四 51nod1186质素检测V2，这里用java实现，否则C++要高精度

题目：

给出1个正整数N，检测N是否为质数。如果是，输出"Yes"，否则输出"No"。

Input

输入一个数N(2 <= N <= 10^30)

Output

如果N为质数，输出"Yes"，否则输出"No"。

代码：

[java]  view plain  copy

1. import java.io.*;  
2. import java.math.*;  
3. import java.util.*;  
4. import java.text.*;  
5. public class nod1186 {  
6.   
7.     /** 
8.      * @param args 
9.      */  
10.     public static void main(String[] args) {  
11.         // TODO Auto-generated method stub  
12.         Scanner cin = new Scanner(new BufferedInputStream(System.in));  
13.         BigInteger N;  
14.         N = cin.nextBigInteger();  
15.         if(IsPrime(N))  
16.         {  
17.             System.out.println("Yes");  
18.         }  
19.         else  
20.             System.out.println("No");  
21.     }  
22.     public static Boolean IsPrime(BigInteger num)  
23.     {  
24.         if(num.compareTo(BigInteger.valueOf(2)) == 0)  
25.             return true;  
26.         if((num.mod(BigInteger.valueOf(2)).compareTo(BigInteger.valueOf(0)) == 0) || (num.compareTo(BigInteger.valueOf(1)) == 0))  
27.             return false;  
28.         BigInteger num_1 = num.subtract(BigInteger.valueOf(1));  
29.         int s = 0;  
30.         while(num_1.mod(BigInteger.valueOf(2)).compareTo(BigInteger.valueOf(0)) == 0)  
31.         {  
32.             num_1 = num_1.divide(BigInteger.valueOf(2));  
33.             ++ s;  
34.         }  
35.         Random ran = new Random();  
36.         for(int i = 0; i < 10; ++ i)  
37.         {  
38.             BigInteger a = BigInteger.valueOf(2);   
39.             BigInteger b = BigInteger.valueOf(Math.abs(ran.nextLong())).mod(num.subtract(BigInteger.valueOf(3)));  
40.             a = a.add(b);  
41.             BigInteger x = FastPowerMod(a,num_1,num);  
42.             if(x.compareTo(BigInteger.valueOf(1)) != 0 && x.compareTo((num.subtract(BigInteger.valueOf(1)))) != 0)  
43.             {  
44.                 Boolean flag = false;  
45.                 for(int j = 1; j < s; ++ j)  
46.                 {  
47.                     BigInteger t = x.multiply(x).mod(num);  
48.                     if(t.compareTo(num.subtract(BigInteger.valueOf(1))) == 0)  
49.                     {  
50.                         flag = true;  
51.                         break;  
52.                     }  
53.                     x = t;  
54.                 }  
55.                 if(flag)  
56.                     continue;  
57.                 return false;  
58.             }  
59.         }  
60.         return true;  
61.     }  
62.     public static BigInteger FastPowerMod(BigInteger a,BigInteger m,BigInteger n)  
63.     {  
64.         BigInteger ans = BigInteger.valueOf(1);  
65.         BigInteger tmp = a;  
66.         while(m.compareTo(BigInteger.valueOf(0)) == 1)  
67.         {  
68.             if(m.mod(BigInteger.valueOf(2)).compareTo(BigInteger.valueOf(1)) == 0)  
69.             {  
70.                 ans = ans.multiply(tmp).mod(n);  
71.             }  
72.             tmp = tmp.multiply(tmp).mod(n);  
73.             m = m.divide(BigInteger.valueOf(2));  
74.         }  
75.         return ans.mod(n);  
76.     }  
77. }