算法分析与设计学习笔记-概率算法

1.概率算法

ch1.基本概念

概率算法分类：

数字算法

MC算法（Monte Carlo）:MC算法总是给出一个答案，但该答案未必正确，成功(即答案是正确的)的概率正比于算法执行的时间,缺点：一般不能有效地确定算法的答案是否正确

LV算法 (Las Vegas算法):获得的答案必定正确，但有时它仍根本就找不到答案。

Sherwood算法:Sherwood算法总是给出正确的答案。当某些确定算法解决一个特殊问题平均的时间比最坏时间快得多时，我们可以使用Sherwood算法来减少，甚至是消除好的和坏的实例之间的差别.

ch2 数字概率算法

π值计算问题

实验：将n根飞镖随机投向一正方形的靶子，计算落入此正方形的内切圆中的飞镖数目k。假定飞镖击中方形靶子任一点的概率相等(用计算机模拟比任一飞镖高手更能保证此假设成立)  设圆的半径为r，面积s1= πr2；方靶面积s2=4r2

解决方法： Darts (n) {

Darts (n) {

k ← 0;
for i ← 1 to n do {
x ← uniform(0, 1);
y ← uniform(0, 1); // 随机产生点(x,y)
if (x2 + y2 ≤ 1) then k++; //圆内
}
return 4k/n;
}

update ——————————

2.2 数字积分计算

1）使用MC积分算法
仍然使用投飞镖计算面积比例
HitorMiss(f,n){
k=0;
for i=1 to n do{
x=uniform(0,1);
y=uniform(0,1);
if y<=f(x) then k++}
return k/n;
}

2）在积分区间上随机均匀的产生点，计算这些点的函数值的算术平均值， 再乘上区间长度
Crude（f,n,a,b){
sum=0;
for i=1 to n do{

x=uniform(a,b);
sum+=f(x);
}
return (b--a)*sum /n;
}
方法2的方差不会大于方法1的方差，但不能说方法2总是优于，因为hitormiss可以在给定时间能迭代更多的次数，例如计算π值的时候不需要计算平方根

3）确定型算法计算积分
梯形，分成N-1个子区间，乘以每个区间的长度
Trapezoid(f,n,a,b){
//n>=2
delta=(b-a)/(n-1);
sum=(f(a)+f(b))/2
for x=a+delta step delta to b-delta do sum += f(x);
return sum *delta;
}
存在的问题：可能球不出解；多重积分问题

2.3 概率计数问题

2.3.1 估计一个整数值，例如x集合的势
思路：有回放的抽样，大集合通过出现第一次重复时来估计集合的大小
x中有n个元素，有回放的随机均匀独立的抽取元素，k为出现第一次重复之前选出的元素数目，当n比较大时，有n=2k^2/pi

SetCount(x){
k=0;
s为空集;
a=uniform(x);
do {
k++;
s=s 并上 {a};
a=uniform(x);
}while a不属于s;
retrun 2k^2/pi;
}

2.3.2:多重集合中不同对象数目的估计
磁带上不同的单词统计，N为总单词数，n为不同单词数目

1）使用外部排序，时间O（NlogN）， 空间要求太大

2）在内存中建立散列表，表中只存储首次出现的单词

3）概率算法，伪随机数将单词序列集合中的单词映射为长度为m的位串（0，1）串

WordCount(){

y[1,..,m+1]={0};//初始化

for each word do {//顺序读取磁带

i=pi(h(x),1);//x的散列值当中等于1的最小位置，表示x以000..01（第i位为第一个1）开头

y[i]=1;//将该位置设置为1

}

retrun pi(y, 0);//返回y中为0的最小位置

}

2.4 在线性代数中，矩阵乘法，求逆，计算特征值和特征向量中一些特殊的应用，概率算法会比确定性算法要好。

ch3 Sherwood算法

可以平滑不同输入实例的执行时间，不再有最坏情况的实例，但是有最坏的执行时间，因为这种偶然性的最坏时间是因为概率选择原因，与输入的实例x没有关系

3.1选择与排序

在n个元素中选择第k个最小的元素

选择划分元的两种方法：挑选一个划分元使之为一个伪中值元素，最换时间为O（n）；取搜索区间第一个元素为划分元，平均时间为O（n），最坏时间为O（n^2）。

使用概率算法：随机选择T中的元素作为划分元

3.2 随机的预处理

将被解的实例变换到一个随机实例。//预处理  ->  用确定算法解此随机实例，得到一个解 ->  将此解变换为对原实例的解 //后处理

RH(x){

//用sherwood算法计算f(x)

n=length[x];//x的size为n

r=uniform(An);//随机取一个元素

y=u(x,r);//将原有实例转化为随机的实例y

s=f(y);//用确定算法来求解y的解s

return v(r,s);

}

eg. 离散的对数计算（可用于密码算法，数字签名等）

原有的算法：

dlog(g,a,p){

x=0;

y=1;

do {

x++;

y=y*g;

}while (a!= y mod p)&&x!=p

return x;

}

随机的离散对数计算(Sherwood算法)

dlogRH（g,a,p）{

r=uniform(0,..p-2);

b=ModularExponent(g,r,p);//求幂模b=g^r mod p

c=ba mod p;//((g^r mod p)(g^x mod p))mod p = g^(r+x) mod p=c

y=log(g,p)c;//使用确定性算法求log(p,g)c, y=r+x;

return (y-r) mod (p-a);//求x

}

3.3搜索有序表

方法一：折半查找 O（lgn）

方法二：顺序查找 O（根号n）

算法对比：

Search(x,i){

while x>val[i] do

i=ptr[i]

return i;

}

//一般的确定性算法

A(x){

return Search(x,head);

}

//O(根号n)的确定算法

B(x){

i=head;

max=val[i];//max初始值是表val中的最小值

for j=1 to (根号n下界) do{//在val的前(根号n下界)中找到不大于x的最大整数y相应的下标

y=val[j];

if max<y<=x then{

i=j;

max=y;}

}

return Search(x,i);//从y开始继续搜索

}

//在B算法的基础上改进的sherwood算法

C(x){

int j,k,i=head;

int max=val[i];

for(j=0;j<sart(n);j++){

k=rand()%n;

//在0-n中取出根号n个随机数作为下标，将这些下标对应的val值与x比较，找出不大于x的最大整数对应的下标

if(max<val[k]&&val[k]<=x){

i=k;

max=val[k];

}

}

return Search(x,i);

}

//O（n）的概率算法

D(x){

y=val[i];

case{

x<y:return Search(x,head);//case 1

x>y: return Search (x,ptr[i]);//case 2

otherwise return i;//case 3 ,x==y

}

}

 

立个flag，慢慢更新学习内容