【随机化算法】蒙特卡罗算法,主元素问题,素数测试问题

0049算法笔记——【随机化算法】蒙特卡罗算法,主元素问题,素数测试问题

分类： 算法 2013-07-05 13:59  215人阅读  评论(0)  收藏  举报

蒙特卡罗算法 主元素问题 素数测试 费尔马小定理 算法笔记

      1、蒙特卡罗算法

      基本概述

       蒙特卡罗（Monte Carlo）方法，又称随机抽样或统计试验方法。传统的经验方法由于不能逼近真实的物理过程，很难得到满意的结果，而蒙特卡罗方法由于能够真实地模拟实际物理过程，故解决问题与实际非常符合，可以得到很圆满的结果。

      在实际应用中常会遇到一些问题，不论采用确定性算法或随机化算法都无法保证每次都能得到正确的解答。蒙特卡罗算法则在一般情况下可以保证对问题的所有实例都以高概率给出正确解，但是通常无法判定一个具体解是否正确。
     设p是一个实数，且1/2<p<1。如果一个蒙特卡罗算法对于问题的任一实例得到正确解的概率不小于p，则称该蒙特卡罗算法是p正确的，且称p-1/2是该算法的优势。
如果对于同一实例，蒙特卡罗算法不会给出2个不同的正确解答，则称该蒙特卡罗算法是一致的。
     有些蒙特卡罗算法除了具有描述问题实例的输入参数外，还具有描述错误解可接受概率的参数。这类算法的计算时间复杂性通常由问题的实例规模以及错误解可接受概率的函数来描述。

     原理思想

      当所要求解的问题是某种事件出现的概率，或者是某个随机变量的期望值时，它们可以通过某种“试验”的方法，得到这种事件出现的频率，或者这个随机变数的平均值，并用它们作为问题的解。这就是蒙特卡罗方法的基本思想。蒙特卡罗方法通过抓住事物运动的几何数量和几何特征，利用数学方法来加以模拟，即进行一种数字模拟实验。它是以一个概率模型为基础，按照这个模型所描绘的过程，通过模拟实验的结果，作为问题的近似解。

     主要步骤

     蒙特卡罗解题归结为三个主要步骤：构造或描述概率过程；实现从已知概率分布抽样；建立各种估计量。

     1)构造或描述概率过程： 对于本身就具有随机性质的问题，如粒子输运问题，主要是正确描述和模拟这个概率过程，对于本来不是随机性质的确定性问题，比如计算定积分，就必须事先构造一个人为的概率过程，它的某些参量正好是所要求问题的解。即要将不具有随机性质的问题转化为随机性质的问题。

     2)实现从已知概率分布抽样： 构造了概率模型以后，由于各种概率模型都可以看作是由各种各样的概率分布构成的，因此产生已知概率分布的随机变量（或随机向量），就成为实现蒙特卡罗方法模拟实验的基本手段，这也是蒙特卡罗方法被称为随机抽样的原因。最简单、最基本、最重要的一个概率分布是(0,1)上的均匀分布（或称矩形分布）。随机数就是具有这种均匀分布的随机变量。随机数序列就是具有这种分布的总体的一个简单子样，也就是一个具有这种分布的相互独立的随机变数序列。产生随机数的问题，就是从这个分布的抽样问题。在计算机上，可以用物理方法产生随机数，但价格昂贵，不能重复，使用不便。另一种方法是用数学递推公式产生。这样产生的序列，与真正的随机数序列不同，所以称为伪随机数，或伪随机数序列。不过，经过多种统计检验表明，它与真正的随机数，或随机数序列具有相近的性质，因此可把它作为真正的随机数来使用。由已知分布随机抽样有各种方法，与从(0,1)上均匀分布抽样不同，这些方法都是借助于随机序列来实现的，也就是说，都是以产生随机数为前提的。由此可见，随机数是我们实现蒙特卡罗模拟的基本工具。 建立各种估计量： 一般说来，构造了概率模型并能从中抽样后，即实现模拟实验后，我们就要确定一个随机变量，作为所要求的问题的解，我们称它为无偏估计。  
     3)建立各种估计量：相当于对模拟实验的结果进行考察和登记，从中得到问题的解。 例如：检验产品的正品率问题，我们可以用1表示正品，0表示次品，于是对每个产品检验可以定义如下的随机变数Ti，作为正品率的估计量： 于是，在N次实验后，正品个数为： 显然，正品率p为： 不难看出，Ti为无偏估计。当然，还可以引入其它类型的估计，如最大似然估计，渐进有偏估计等。但是，在蒙特卡罗计算中，使用最多的是无偏估计。 用比较抽象的概率语言描述蒙特卡罗方法解题的手续如下：构造一个概率空间(W ,A,P)，其中，W 是一个事件集合，A是集合W 的子集的s 体，P是在A上建立的某个概率测度；在这个概率空间中，选取一个随机变量q (w ),w Î W ,使得这个随机变量的期望值 正好是所要求的解Q ，然后用q (w )的简单子样的算术平均值作为Q 的近似值。

      2、主元素问题

     问题描述

     设T[1:n]是一个含有n个元素的数组。当|{i|T[i]=x}|>n/2时，称元素x是数组T的主元素。 例如：数组T[]={5,5,5,5,5,5,1,3,4,6}中，元素T[0:5]为数组T[]的主元素。

     问题求解

      算法随机选择数组元素x,由于数组T的非主元素个数小于n/2，所以，x不为主元素的概率小于1/2。因此判定数组T的主元素存在性的算法是一个偏真1/2正确的算法。50%的错误概率是不可容忍的，利用重复调用技术将错误概率降低到任何可接受的范围内。对于任何给定的>0，算法majorityMC重复调用次算法majority。它是一个偏真蒙特卡罗算法，且其错误概率小于。算法majorityMC所需的计算时间显然是。

     算法具体代码如下：

[cpp]  view plain copy

1. //随机化算法 蒙特卡罗算法 主元素问题  
2. #include "stdafx.h"  
3. #include "RandomNumber.h"  
4. #include <cmath>  
5. #include <iostream>  
6. using namespace std;  
7.   
8. //判定主元素的蒙特卡罗算法  
9. template<class Type>  
10. bool Majority(Type *T,int n)  
11. {  
12.     RandomNumber rnd;  
13.     int i = rnd.Random(n);  
14.   
15.     Type x = T[i];  //随机选择数组元素  
16.     int k = 0;  
17.   
18.     for(int j=0; j<n; j++)  
19.     {  
20.         if(T[j] == x)  
21.         {  
22.             k++;  
23.         }  
24.     }  
25.   
26.     return (k>n/2);  //k>n/2时，T含有主元素  
27. }  
28.   
29. //重复k次调用算法Majority  
30. template<class Type>  
31. bool MajorityMC(Type *T,int n,double e)  
32. {  
33.     int k = ceil(log(1/e)/log((float)2));  
34.     for(int i=1; i<=k; i++)  
35.     {  
36.         if(Majority(T,n))  
37.         {  
38.             return true;  
39.         }  
40.     }  
41.     return false;  
42. }  
43.   
44. int main()  
45. {  
46.     int n = 10;  
47.     float e = 0.001;  
48.     int a[] = {5,5,5,5,5,5,1,3,4,6};  
49.     cout<<"数组a的元素如下："<<endl;  
50.     for(int i=0; i<10; i++)  
51.     {  
52.         cout<<a[i]<<" ";  
53.     }  
54.     cout<<endl;  
55.     cout<<"调用MajorityMC判断数组是否含有主元素结果是："<<MajorityMC(a,n,e)<<endl;  
56. }  

    程序运行结果如图：

     3、素数测试问题

     数学原理

     Wilson定理：对于给定的正整数n，判定n是一个素数的充要条件是(n-1)! -1(mod n)。
     费尔马小定理：如果p是一个素数，且0<a<p，则a^(p-1)(mod p)。 
     二次探测定理：如果p是一个素数，且0<x<p，则方程x^21(mod p)的解为x=1，p-1。

     Carmichael数：费尔马小定理是素数判定的一个必要条件。满足费尔马小定理条件的整数n未必全是素数。有些合数也满足费尔马小定理的条件，这些合数称为Carmichael数。前3个Carmichael数是561,1105，1729。Carmichael数是非常少的，在1~100000000的整数中，只有255个Carmichael数。

     求a^m(mod n)的算法

     设m的二进制表示为bkbk-1…b1b0（bk=1）。
     例：m=41=101001(2)，bkbk-1…b1b0=101001，（k=5）。
     可以这样来求a^m：初始C←1。
     b5=1：C←C^2(=1)，∵bk=1，做C←a*C(=a)；
     b5b4=10：C←C^2(=a^2)，∵bk-1=0，不做动作；
     b5b4b3=101：C←C^2(=a^4)，∵bk-2=1，做C←a*C(=a^5)；
     b5b4b3b2=1010：C←C^2(=a^10)，∵bk-3= b2=0，不做动作；
     b5b4b3b2b1=10100：C←C^2(=a^20)，∵bk-4= b1=0，不做动作；
     b5b4b3b2b1b0=101001：C←C^2(=a^40)，∵bk-5= b0=1，做C←a*C(=a^41)。
     最终要对am求模，而求模可以引入到计算中的每一步：
     即在求得C2及a*C之后紧接着就对这两个值求模，然后再存入C。
     这样做的好处是存储在C中的最大值不超过n-1，
     于是计算的最大值不超过max{(n-1)^2,a(n-1)}。
     因此，即便am很大，求am(mod n)时也不会占用很多空间。

     程序具体代码如下：

[cpp]  view plain copy

1. //随机化算法 蒙特卡罗算法 素数测试问题  
2. #include "stdafx.h"  
3. #include "RandomNumber.h"  
4. #include <cmath>  
5. #include <iostream>  
6. using namespace std;  
7.   
8. //计算a^p mod n,并实施对n的二次探测  
9. void power(unsigned int a,unsigned int p,unsigned int n,unsigned int &result,bool &composite)  
10. {  
11.     unsigned int x;  
12.     if(p == 0)  
13.     {  
14.         result = 1;  
15.     }  
16.     else  
17.     {  
18.         power(a,p/2,n,x,composite);     //递归计算  
19.         result = (x*x)%n;               //二次探测  
20.   
21.         if((result == 1) && (x!=1) && (x!=n-1))  
22.         {  
23.             composite  = true;  
24.         }  
25.   
26.         if((p%2)==1)  
27.         {  
28.             result = (result*a)%n;  
29.         }  
30.     }  
31. }  
32.   
33. //重复调用k次Prime算法的蒙特卡罗算法  
34. bool PrimeMC(unsigned int n,unsigned int k)  
35. {  
36.     RandomNumber rnd;  
37.     unsigned int a,result;  
38.     bool composite = false;  
39.   
40.     for(int i=1; i<=k; i++)  
41.     {  
42.         a = rnd.Random(n-3)+2;  
43.         power(a,n-1,n,result,composite);  
44.         if(composite || (result!=1))  
45.         {  
46.             return false;  
47.         }  
48.     }  
49.     return true;  
50. }  
51.   
52. int main()  
53. {  
54.     int k = 10;  
55.     for(int i=1010;i<1025;i++)  
56.     {  
57.         cout<<i<<"的素数测试结果为："<<PrimeMC(i,k)<<endl;  
58.     }  
59.     return 0;  
60. }  

     程序运行结果如图：

 

0048算法笔记——【随机化算法】拉斯维加斯随机化算法求解整数因子分解中的因子分割问题

分类： 算法 2013-07-04 21:51  146人阅读  评论(0)  收藏  举报

随机化算法 整数因子分解 因子分割问题 算法笔记 拉斯维加斯算法

      问题描述

     设n>1是一个整数。关于整数n的因子分解问题是找出n的如下形式的唯一分解式：。其中，p1<p2<…<pk是k个素数，m1,m2,…,mk是k个正整数。如果n是一个合数，则n必有一个非平凡因子x，1<x<n，使得x可以整除n。给定一个合数n，求n的一个非平凡因子的问题称为整数n的因子分割问题。

    求解思路

     整数因子分解最直观的方法当数“试除法”，数论中的Mertens定理告诉我们76%的奇数都有小于100的素因子，因此对于大多数整数，“试除法”已经足够，但是对于特殊的数，特别是素因子普遍较大的时候，“试除法"的效率便明显不足。和素数检验类似，目前几乎所有实用的分解方法都是概率性的算法, 目标是找到能计算x 的算法, 使得(x,N) > 1 的概率较大(而最大公因子可以很快地计算).      

    试除法因子分割如下：

[cpp]  view plain copy

1. int Split(int n)  
2. {  
3.     int m = floor(sqrt(double(n)));  
4.     for (int i=2; i<=m; i++)  
5.     {  
6.         if (n%i==0)  
7.         {  
8.             return i;  
9.         }  
10.     }  
11.     return 1;  
12. }  

      算法split(n)是对范围在1～x的所有整数进行了试除而得到范围在1～x^2的任一整数的因子分割。 

      Pollard p - 1 方法由Pollard 于1974 年提出，用来找到给定合数n的一个因子d。Pollard算法用于Split(n)相同工作量就可以得到在1～x^4范围内整数的因子分割。具体过程如下：在开始时选取0～n-1范围内的随机数，然后递归地由
产生无穷序列对于i=2^k，以及2^k<j<=2^(k+1)，算法计算出xj-xi与n的最大公因子d=gcd(xj-xi，n)。如果d是n的非平凡因子，则实现对n的一次分割，算法输出n的因子d。

     算法具体实现如下：

     1、RandomNumber.h

[cpp]  view plain copy

1. #include"time.h"  
2. //随机数类  
3. const unsigned long maxshort = 65536L;  
4. const unsigned long multiplier = 1194211693L;  
5. const unsigned long adder = 12345L;  
6.   
7. class RandomNumber  
8. {  
9.     private:  
10.         //当前种子  
11.         unsigned long randSeed;  
12.     public:  
13.         RandomNumber(unsigned long s = 0);//构造函数，默认值0表示由系统自动产生种子  
14.         unsigned short Random(unsigned long n);//产生0：n-1之间的随机整数  
15.         double fRandom(void);//产生[0,1)之间的随机实数  
16. };  
17.   
18. RandomNumber::RandomNumber(unsigned long s)//产生种子  
19. {  
20.     if(s == 0)  
21.     {  
22.         randSeed = time(0);//用系统时间产生种子  
23.     }  
24.     else  
25.     {  
26.         randSeed = s;//由用户提供种子  
27.     }  
28. }  
29.   
30. unsigned short RandomNumber::Random(unsigned long n)//产生0：n-1之间的随机整数  
31. {  
32.     randSeed = multiplier * randSeed + adder;//线性同余式  
33.     return (unsigned short)((randSeed>>16)%n);  
34. }  
35.   
36. double RandomNumber::fRandom(void)//产生[0,1)之间的随机实数  
37. {  
38.     return Random(maxshort)/double(maxshort);  
39. }  

     2、7d4d2.cpp

[cpp]  view plain copy

1. //随机化算法 拉斯维加斯算法 因子分割问题  
2. #include "stdafx.h"  
3. #include "RandomNumber.h"  
4. #include <iostream>  
5. using namespace std;  
6.   
7. //求整数a和b最大公因数的欧几里得算法  
8. int gcd(int a,int b)  
9. {  
10.     if(b==0)  
11.     {  
12.         return a;  
13.     }  
14.     else  
15.     {  
16.         return gcd(b,a%b);  
17.     }  
18. }  
19.   
20. //求整数n因子分割的拉斯维加斯算法  
21. void Pollard(int n)  
22. {  
23.     RandomNumber rnd;  
24.     int i = 1;  
25.     int x = rnd.Random(n);          //随机整数  
26.     int y = x;  
27.     int k = 2;  
28.   
29.     while(true)  
30.     {  
31.         i++;  
32.         x = (x*x - 1) % n;          //x[i]=(x[i-1]^2-1) mod n  
33.         int d = gcd(y-x,n);         //求n的非平凡因子  
34.   
35.         if((d>1) && (d<n))  
36.         {  
37.             cout<<d<<endl;//因子分割问题：求n的[一]个非平凡因子的问题  
38.             return;  
39.         }  
40.   
41.         if(i == k)  
42.         {  
43.             y = x;  
44.             k *= 2;  
45.         }  
46.     }  
47. }  
48.   
49. int main()  
50. {  
51.     int n = 1024;  
52.     cout<<n<<"的非平凡因子："<<endl;  
53.     Pollard(n);  
54.     return 0;  
55. }  

     对Pollard算法更深入的分析可知，执行算法的while循环约次后，Pollard算法会输出n的一个因子p。由于n的最小素因子，故Pollard算法可在O(n^(1/4))时间内找到n的一个素因子。

     程序运行结果如图：