登山算法

登山算法

在A*算法中,估价函数f(x)=k*g(x)+w*h(x),即是由已付出的代价函数g(x)和启发函数(希望函数)h(x)两个方面组成,而登山算法在搜索过程中,估价函数f(x)则是只有启发函数(希望函数)h(x)组成,即登山算法的估价函数f(x)=h(x).

登山算法的搜索过程为:

1.保存并取出初始结点.

2.用生成器函数G(X),由该结点出发生成下一级子结点, 并检查是否出现目标状态Sg(终止结点),若出现,则转4;否则继续

3.

3.用估价函数f(X)=h(x)对生成的该层各结点进行估价, 根据需要选取估价值(希望值)最小(最大)的一个结点作为最有希望的结点保存起来,然后再取出该结点(将被优先扩展),转2.

4.搜索成功,打印搜索的结果.

登山算法的直接含义,就是在该结点的下一层结点中,找到一个希望值最小或最大的结点进行扩展,一直这样走下去,不回头.在搜索的过程中,每次保存的结点既是每层最有希望的结点,也是解路径上的结点.

正因为登山算法有单刀直入的特点,因此,在编程序中,使用登山算法必须注意,若问题本身是属于"单峰"情况的,则登山算法就可直接求得最优解; 若在"多峰"情况下,则使用登山算法,就可能得不到最优解,而得到的是次优解或更次优解.

请看如下的例子.

【马的周游问题】

如下给出一个8*8的棋盘.现有一个马在棋盘的初始位置是随机给出的, 设为(X0,Y0).

┎┰┰┰┰┰┰┰┒马由初始点按跳日字规则在棋盘上进行周游, 棋盘上的每个┠╂╂╂╂╂╂╂┨点只能跳一次,问马该如何跳,恰好使马能跳到棋盘上的每一┠╂╂╂╂╂╂╂┨个点.试编程序,输出马的一种遍历棋盘的方案.

┠╂╂╂╂╂╂╂┨思路: 马的周游问题是一道传统的题目. 由于马在棋盘┠╂╂╂╂╂╂╂┨上的任意一点最多可按八个方向跳出,所以,该题最简单的解┠╂╂╂╂╂╂╂┨决办法就是采用搜索策略, 即: 在某一点先沿某一个方向跳┠╂╂╂╂╂╂╂┨出,当跳到某一步,某点的八个方向都不能再跳时, 则退回到┠╂╂╂╂╂╂╂┨上一点,在该点再沿另一个可跳方向跳出, 重复此搜索过程, ┖┸┸┸┸┸┸┸┚直到找到一种遍历的方案为止.

用全搜索的策略来寻找马的一种遍历方案,会遇到一个很严重的问题,就是搜索量太大.在全搜索的策略下,其搜索量在最坏的情况下,要搜索8`+64!`.因此,马的周游问题用全搜索策略来进行解答,不是一种好的解决方法.我们可以采用带启发信息的搜索策略,如:A*算法来进行求解,这样不仅可减少搜索的信息量,还可较快地寻找出马的遍历方案.

在这里,我们采用另外一种算法,采用一种不可撤回的搜索算法━━登山算法, 来求解马的周游棋盘的方案.

登山算法的处理过程,就是在某一点(层)对所有可能的搜索方向选择估价值最小(最大)的方向进行搜索,这个过程不断重复,一直进行下去(不回溯),直到生成解路径为止.

用登山算法求马的遍历方案,其处理过程如下:

用数组dx[i]表示列的位移量,数组dy[i]表示行的位移量,如下所示:

┎─┰─┰─┰─┰─┒

┃┃8 ┃┃1 ┃┃

┠─╂─╂─╂─╂─┨┎───┰─┰─┰─┰─┰─┰─┰─┰─┒

┃7 ┃┃┃┃2 ┃┃方向i=┃1 ┃2 ┃3 ┃4 ┃5 ┃6 ┃7 ┃8 ┃

┠─╂─╂─╂─╂─┨┠───╂─╂─╂─╂─╂─╂─╂─╂─┨

┃┃┃马┃┃┃┃dx[i] ┃1 ┃2 ┃2 ┃1 ┃-1┃-2 ┃-2┃-1┃

┠─╂─╂─╂─╂─┨┠───╂─╂─╂─╂─╂─╂─╂─╂─┨

┃6 ┃┃┃┃3 ┃┃dy[i] ┃2 ┃1 ┃-1┃-2 ┃-2┃-1┃1 ┃2 ┃

┠─╂─╂─╂─╂─┨┖───┸─┸─┸─┸─┸─┸─┸─┸─┚

┃┃5 ┃┃4 ┃┃

┖─┸─┸─┸─┸─┚方向位移量

图8.15 马的可跳方向

数组x[n]和y[n]分别表示存放马已走过的列和行坐标位置.变量n表示马跳的步数. 数组v[j,i]表示棋盘上坐标为(i,j)(i表示列,j表示行)的点是否走过标记.v[j,i]:=0表示该点没走过;v[j,i]:=n表示该点是第n步走过.变量dir表示方向值, 变量d表示某点的可跳方向数,变量f表示最小方向数.

(1). 设初值: 随机产生初始点的坐标位置(c,r),c表示列,r表示行.设n:=1,并将初始位置存入堆栈x[n]和y[n]中,并使v[r,c]:=n;

(2). 若n<64不成立,则转(5)打印解路径.若成立,则n:=n+1,并设最小方向数f:=9, 同时取出(n-1)点的坐标值给变量r,c,并继续(3);

(3). 在(n-1)步的位置上去计算,若沿八个方向分别跳出第n步,则跳出第n步后的坐标位置是否在棋盘的位置内,若不在棋盘内,则选另一个方向跳第n步;若在棋盘内, 则先判断跳出后的点是否已经被访问过,若访问过,则再选另一个方向跳第n步;若没有被访问过, 则计算跳出后的点,在该点上还有多少个可跳点,其可跳点数为d.若d

(4). 在(n-1)步沿方向dir跳出第n步后,计算其坐标位置为(r1,c1), 并将坐标值存入堆栈x[n]和y[n]中,同时设标记: v[r1,c1]:=n.再转(2);

(5). 打印解路径.

根据如上过程,可编程序如下:

program LT8_14;

const dx: array[1..8] of shortint=(1,2,2,1,-1,-2,-2,-1);

dy: array[1..8] of shortint=(2,1,-1,-2,-2,-1,1,2);

var x,y:array[1..64] of integer;

v:array[1..8,1..8] of integer;

r,c,i,j,n,f,d,c1,r1,dir,Gd,Gm:integer;

s:string[2];

procedure min(y,x:integer;var m:integer); {计算某点的可跳方向数}

var i,j,x1,y1:integer;

begin

m:=0;

for i:=1 to 8 do

begin

x1:=x+dx[i];y1:=y+dy[i];

if (x1>0)and(x1<9)and(y1>0)and(y1<9) then

if v[y1,x1]=0 then m:=m+1;

end;

end;

begin

fillchar(v,sizeof(v),0);randomize;

n:=1;r:=1+random(8);c:=1+random(8); {随机产生一个坐标点(c,r)}

x[n]:=c;y[n]:=r;v[r,c]:=n; {初值进堆栈,并设标记}

while n<64 do {判断64个点是否都跳完}

begin

n:=n+1;f:=9; {预跳第n步}

c:=x[n-1];r:=y[n-1]; {取出第n-1步的坐标}

for i:=1 to 8 do {在第n-1步的坐标上计算八}

begin {个方向的可跳数}

c1:=c+dx[i];r1:=r+dy[i]; {沿第i方向跳出的坐标}

if (c1>0)and(c1<9)and(r1>0)and(r1<9) then {判断是否越界}

if v[r1,c1]=0 then {若没出界,则新坐标是否已跳过}

begin

min(r1,c1,d); {若没跳过,则计算该点的可跳数}

if d

end;

end;

c1:=c+dx[dir];r1:=r+dy[dir]; {沿可跳数最小的方向跳出}

x[n]:=c1;y[n]:=r1;v[r1,c1]:=n {记录跳出的坐标,并作标记}

end;

for i:=1 to 64 do

begin

str(i,s);r:=y[i]*30+12;c:=x[i]*30+8;

end;

end.

执行如上程序,则屏幕会以图形方式显示出一种马的遍历方案.如下给出了两种遍历的方案:

44 51 12 57 26 5 10 7 64 13 30 33 44 15 28 19

13 58 43 50 11 8 25 4 31 34 63 14 29 18 41 16

52 45 60 29 56 27 6 9 12 61 32 45 58 43 20 27

59 14 55 42 49 30 3 24 35 50 59 62 25 40 17 42

46 53 48 61 28 35 20 31 60 11 54 39 46 57 26 21

15 62 39 54 41 32 23 2 49 36 51 56 53 24 3 6

38 47 64 17 36 21 34 19 10 55 38 47 8 5 22 1

63 16 37 40 33 18 1 22 37 48 9 52 23 2 7 4

由以上例子可知,采用登山算法解题,由于在搜索过程中是不回溯的,因此,出结果的速度就非常快,生成的空间也小,这是登山算法的优点, 但登山算法毕竟是一种不完备的搜索算法,因此,使用时要特别注意.