第6章 随机化算法

bool majorityMC(Type T[], int n, double p) { // 重复次调用多次算法majority
int k= (int) ceil(log()/log(1-p)); for (int i=1;i<=k;i++) if (majority(T,n)) return true; return false;
舍伍德(Sherwood)算法
（2）线性时间选择算法改造为舍伍德算法 舍伍德型选择算法： 随机的选择一个数组元素作为划分基准。 这样既能保证算法的线性时间平均性能，又能 避免算法的拟中位数的麻烦。

template<class Type> Type select(Type a[ ], int left, int right, int k) { RandomNumber rnd; if(left>=right) return a[left]; int i=left, j=rnd.Random(right-left+1)+left； swap(a[i], a[ j]); j=Partition(a,left,right); int count=j-left+1; if(count<k) select(a[ ],j+1, right, k-count); else select(a[ ],left, j, k); }
数值随机化算法-计算定积分
设f(x)是[0,1]上的连续函数且0≤f(x)≤1，需要 1 计算积分值
I
1

0
f ( x ) dx
y y = f(x ) G x
0
1
图 6 -2 随 机 投 点 实 验 估 算 I 值 示 意 图
假设向单位正方形内随机投入n个点，如果有m个 点落入G内，则I近似等于随机点落入G内的概率， 即I≈m/n
蒙特卡罗(Monte Carlo)算法
蒙特卡罗算法用于求问题的准确解。 用蒙特卡罗算法能求得问题的一个解， 但这个解未必是正确的。求得正确解的 概率依赖于算法所用的时间。 缺点：一般情况下，无法有效地判定所 得到的解是否肯定正确。
设蒙特卡罗算法是一致的p正确的。那 么至少调用多少次蒙特卡罗算法，可 以使得蒙特卡罗算法得到正确解的概 率不低于 ？
n 皇后问题
问题描述
n皇后问题要求将n个皇后放在n×n棋盘的不 同行、不同列、不同斜线的位置，找出相应的 放置方案
随机化措施
对某行放置皇后的有效位置进行随机 对某行所有列位置进行随机
n 皇后问题
Class Queen{ public: friend void nQueen(int); private: bool Place(int k); //测试皇后k置于第x[k]列的合法性 bool QueenLV(void); //随机放置n个皇后拉斯维加斯算法 int n, *x,*y; //n表示皇后个数，x和y表示解向量 }； Bool Queen:Place(int k) { for(int j=1;j<k;j++) if((abs(k-j)==abs(x[ j]-x[k]))||(x[ j]==x[k])) return false; return true; }
随机数发生器
a0 d a n ( ba c ) mod m n 1, 2 ,
n 1
选取该方法中的常数b、c和m直接关系到所产生的 随机序列的随机性能 d为种子； b为系数，满足b≥0； c为增量，满足c≥0； m为模数，满足m>0。 b、c和m越大，且b与m互质，可使随机函数的随机 性能更好

4k n
数值随机化算法-计算PAI
double Darts(int n) { static RandomNumber darts; //定义一个RandomNumber类的对象darts int k=0,i; double x,y; for( i=1;i<=n;i++) { x=darts.fRandom(); //产生一个[0,1)之间的实数，赋给x y=darts.fRandom(); //产生一个[0,1)之间的实数，赋给y if((x*x+y*y)<=1) k++; } return 4*k/double(n); }
数值随机化算法
6.2.1计算π的值
将n个点随机投向一个正方形，设落入此正方形 内切圆（半径为r）中的点的数目为k，如图6-1a） 所示。
y 1
a)
0
b)
1
x
数值随机化算法-计算PAI
假设所投入的点落入正方形的任一点的概率相等， 则所投入的点落入圆内的概率为
r
4r
2 2


4
当n足够大时， k与n之比就逼近这一概率，从而
对某行所有列位置进行随机的拉斯维加斯算法 bool Queen::QueensLV1(void) //棋盘上随机放置n个皇后拉斯维加斯算法 { RandomNumber rnd; //随机数产生器 int k=1; //下一个放置的皇后编号 int count=maxcout;//尝试产生随机位置的最大次数，用户根据需要设置 while(k<=n) { int i=0; for(i=1;i<=count;i++) { x[k]=rnd.Random(n)+1; if(Place(k)) break; //第k个皇后在第k行的有效位置存于y数组 } if(i<=count) k++; else break; } return (k>n); //k>n表示放置成功 }
}
6.4 拉斯维加斯( Las Vegas )算 法
拉斯维加斯算法不会得不到正确的 解。一旦用拉斯维加斯算法找到一个解， 这个解就一定是正确的。但有时用拉斯维 加斯算法会找不到解。它找到解的概率随 着它所用的计算时间的增加而提高。对于 求解问题的任一实例，用同一拉斯维加斯 算法反复对该实例求解足够多次，可使求 解失效的概率任意小。
数值随机化算法常用于数值问题的求解，所得到的解 往往都是近似解，而且近似解的精度随计算时间的增 加不断提高。 它能求得问题的一个解，但这个解未必是正确的。求 得正确解的概率依赖于算法执行时所用的时间，所用 的时间越多得到正确解的概率就越高。一般情况下， 蒙特卡罗算法不能有效地确定求得的解是否正确。 拉斯维加斯算法不会得到不正确的解，一旦找到一个 解，那么这个解肯定是正确的。但是有时候拉斯维加 斯算法可能找不到解。拉斯维加斯算法得到正确解的 概率随着算法执行时间的增加而提高。 舍伍德算法不会改变对应确定性算法的求解结果，每 次运行都能够得到问题的解，并且所得到的解是正确 的
6.5 舍伍德(Sherwood)算法
设A是一个确定性算法，当它的输入实例为x时所需的计算时间 记为tA(x)。设Xn是算法A的输入规模为n的实例的全体，则当问题 的输入规模为n时，算法A所需的平均时间为 t (n) t ( x) / | X |
A A n x X
n
这显然不能排除存在x∈Xn使得t ( x ) t ( n ) 的可能性。希望获 得一个概率算法B，使得对问题的输入规模为n的每一个实例均 有 t ( x) t A (n) s(n)

舍伍德(Sherwood)算法
（1）线性时间选择算法 线性时间选择问题:给定线性序集中n个 元素和一个整数k,1<=k<=n要求找出这n 个元素中第k小的元素。 如果将这n个元素依其线性序排列时， 排在第k个位臵的元素即为我们要找的元素。 当k=1时，找第一个元素，k=n时， 找最后一个元素，k=(n+1)/2找中位数。 该方法的最坏情况下时间复杂性为O(n)。 平均情况下时间复杂性为O(logn)
A A
B
这就是舍伍德算法设计的基本思想。当s(n)与tA(n)相比可忽略 时，舍伍德算法可获得很好的平均性能。
舍伍德(Sherwood)算法
舍伍德算法总能求得问题的一个解, 且所求得的解总是正确的。当一个确定性算 法在最坏情况下的计算复杂性与其在平均情 况下的计算复杂性有较大差别时，可在这个 确定性算法中引入随机性将它改造成一个舍 伍德算法，消除或减少问题的好坏实例间的 这种差别。舍伍德算法精髓不是避免算法的 最坏情况行为，而是设法消除这种最坏情形 行为与特定实例之间的关联性。
(0 1 p )
主元素问题
设T[1:n]是一个含有n个元素的数组。当 |{i|T[i]=x}|>n/2时，称元素x是数组T的主元素
Template<class Type> bool majority(Type T[], int n) // 判定主元素的蒙特卡罗算法 { RandomNumber rnd; int i=rnd.random(n)+1; //产生1~n之间的随机下标 Type x=T[i]; // 随机选择数组元素 int k=0; for (int j=1;j<=n;j++) if (T[j]==x) k++; return (k>n/2); //当 k>n/2 时，T含有主元素 }
第6章 随机化算法
张阳 信息工程学院
第六章 随机化算法
伪随机数 数值随机化算法 蒙特卡罗算法 拉斯维加斯算法 舍伍德算法
随机数发生器
随机数发生器
产生随机数的方法
伪随机数发生器
通过一个固定的、可以重复的计算方法产生随 机数的发生器
a0 d a n ( ba n 1 c ) mod m ， n 1, 2
拉斯维加斯( Las Vegas )算 法
拉斯维加斯算法的一个显著特征是它所作的随 机性决策有可能导致算法找不到所需的解。因此通 常用一个bool型函数表示拉斯维加斯算法。当算法 找到一个解时返回true，否则返回false。拉斯维加 斯算法的典型调用形式为bool success=LV(x,y)； 其中x是输入参数；当success的值为true时，y返 回问题的解。当success为false时，算法未能找到 问题的一个解。此时可对同一实例再次独立地调用 相同的算法。