广度搜索.docx

1、广度搜索第二节 广度优先搜索一、广度优先搜索在深度优先搜索中，深度越大的结点越先得到扩展；如果将深度越小的结点越先得到扩展，那便是广度优先搜索。广度优先搜索类似于树的按层次遍历的过程，它从初始点开始，应用算符生成第一层结点，检查目标结点是否在这些后继结点中；若没有，再用算符将所有第一层的结点逐一扩展，生成第二层结点，并逐一检查第二层结点中是否包含目标结点；若没有，再用算符将所有第二层的结点逐一扩展，生成第三层结点，并逐一检查第三层结点中是否包含目标结点；如此依次扩展、检查下去，直到发现目标结点为止。广度优先搜索为了满足先生成的结点先扩展的原则，采用队列的数据结构来存贮结点。队列是一种线性表，对

2、于它所有的进队都在表尾的一端进行，所有的出队都在表首的一端进行。如同现实生活中的等车、买票的排队，新来的总是加入队尾，每次离开的总是队首的人。例 1-2-1 下面是六个城市之间道路联系的示意图，连线表示两城市之间有道路相通。请编一程序，由计算机找出从C1城到C6城的没有重复城市的所有不同的路径。const link : array1.5,1.6 of byte = (0,1,1,0,0,0), (1,0,1,1,1,0), (1,1,0,1,1,0), (0,1,1,0,1,1), (0,1,1,1,0,1);type ft = set of 1.6;var qm队列,pntparent父节点

3、 : array1.100 of byte; f走到这里通过的城市 : array1.100 of ft; fs : ft; i,k,closed,open : byte;procedure print;var n,i,j : byte; s : array1.6 of byte;begin i := open; n := 0; while i 0 do begin n := n+1; sn := i; i := pnti; end; write(Dep = ,n-1, : 1); for j := n-1 downto 1 do begin write( - ,qmsj); end; rea

4、dln;end;begin f1 := 1城市1已到; qm1 := 1队列的第一个节点是1; pnt1 := 0;没有父辈节点 closed := 0; open := 1; repeat inc(closed); k := qmclosed; if k 6 then begin fs := fclosed; for i := 2 to 6 do if (not(i in fs) and (linkk,i 0) then begin inc(open); qmopen := i; fopen := fs+i; pntopen := closed; if i = 6 then print; e

5、nd; end; until closed = open;end.在广度优先搜索中，我们将扩展出来的结点存贮在一个称作qm的数组里，qm数组采用“先进先出”的队列结构，设两个指针closed和open，分别是队首指针和队尾指针。其中qm1.closed-1存贮已扩展的结点（即这些结点的子结点已扩展出）；qmclosed.open存贮待扩展结点（即这些结点的子结点尚待扩展）。当closed = open则表示队列空，结束。pnt为父辈结点数组，它记录了每个结点的父辈结点，当找到目标后，可沿着父辈结点倒串上去，输出路径方案。在广度优先搜索中，第一个达到目标结点的，即是最短路径。例 1-2-2 有一

6、个由四个1和四个0，中间有一个空格组成的字符串1111 0000，现规定： 1只能向右运动，0只能向左运动。 空格左右的1或0可以移动，进入空格。 1可以跳过一个0，进入空格；0也可以跳过一个1，进入空格。 要求在符合上述规定的方式下，以最少的步骤，将其变为字符串0000 1111，编程打印输出运动的每一步。type a9 = string9; qt = record a : a9; x,pnt : byte; end;var qm : arraybyte of qt; temp : qt; closed,open : byte;Procedure print; Var buf : array

7、1.30 of byte; i,j : byte; begin i := open; j := 0 while i 0 do begin inc(j); bufj := i; i := qmi.pnt; end; for i := j downto 1 do begin write(No.,i-j:2, : ,qmbufi.a); readln; end; halt; end;procedure comp; var i : byte; begin for i := 1 to open do if qmi.a = temp.a then exit; open := open+1; qmopen.

8、a := temp.a; qmopen.x := temp.x; qmopen.pnt := closed; if temp.a = 0000 1111 then print; end;procedure opa; begin temp := qmclosed; with temp do if (x 1) and (ax-1 = 1) then begin ax-1 := ; ax := 1; x := x-1; comp; end; end;procedure opb; begin temp := qmclosed; with temp do if (x 2) and (ax-1 = 0)

9、and (ax-2 = 1) then begin ax-2 := ; ax := 1; x := x-2; comp; end; end;procedure opd; begin temp := qmclosed; with temp do if (x 8) and (ax+1 = 1) and (ax+2 = 0) then begin ax+2 := ; ax := 0; x := x+2; comp; end; end;begin with qm1 do begin a := 1111 0000; x := 5; pnt := 0; end; closed := 0; open :=

10、1; while closed 0 do begin j := j+1; sj := i; i := qmi.pnt; end; writeln(qm1.x); writeln(qm1.y); writeln; for i := j-1 downto 1 do begin writeln(Oprate : ,qmsi.op); writeln(qmsi.x); writeln(qmsi.y); readln; end; halt;end;procedure comp(opx : char);var i : integer;begin for i := 1 to open do if (m =

11、qmi.x) and (n = qmi.y) then exit; open := open+1; qmopen.x := m; qmopen.y := n; qmopen.op := opx; qmopen.pnt := closed; if (m = k) and (n = l) then print;end;procedure opa;begin m := qmclosed.y; n := qmclosed.x; comp(a);end;procedure opb;begin m := (qmclosed.x mod 10)*100+(qmclosed.x div 10); n := (

12、qmclosed.y mod 10)*100+(qmclosed.y div 10); comp(b);end;procedure opc;var a,b,c,d : integer;begin a := qmclosed.x div 100; b := qmclosed.x mod 100 div 10; c := qmclosed.y div 100; d := qmclosed.y mod 100 div 10; m := c*100+a*10+(qmclosed.x mod 10); n := d*100+b*10+(qmclosed.y mod 10); comp(c);end;be

13、gin write(Input Source M(1,2,3) : ); readln(qm1.x); write(Input Source N(6,5,4) : ); readln(qm1.y); writeln; write(Input Object K(1,2,3) : ); readln(k); write(Input Object L(6,5,4) : ); readln(l); writeln; qm1.pnt := 0; closed := 0; open := 1; while closed open do begin closed := closed+1; opa; opb;

14、 opc; end;end.例 1-2-4 八数码问题：在3*3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一个数字，棋盘上留有一个空格，空格周围的棋子可以移到空格中。要求给出一种初始状态和一种目标状态，找出一种最少步骤的移动方法，实现从初始状态到目标状态的转变。例如： 初始状态 目标状态 2 8 3 1 2 3 1 6 4 8 4 7 5 7 6 5Type a33 = array1.3,1.3 of byte; a4 = array1.4 of -1.1; node = record ch : a33; y,x : byte; pnt : word; end;Const start :

15、 a33 = (2,8,3),(1,6,4),(7,0,5); goal : a33 = (1,2,3),(8,0,4),(7,6,5); x1 = 2; y1 = 3; max = 4800; dx : a4 = (0,-1,0,1); dy : a4 = (-1,0,1,0);Var data : array1.max of node; temp : node; r,tx,ty : byte; closed,open : word;Function check(k : byte) : boolean;begin ty := temp.y+dyk; tx := temp.x+dxk; if

16、(ty in 1.3) and (tx in 1.3) then check := true else check := false;end;Function dupe : boolean;Var i : word; j,k : integer; b : boolean;begin i := 0; repeat inc(i); b := true; for j := 1 to 3 do for k := 1 to 3 do if datai.chj,k dataopen.chj,k then b := false; until b or (i = open-1); dupe := b;end;

17、Function goals : boolean;Var i,j : byte;begin goals := false; for i := 1 to 3 do for j := 1 to 3 do if dataopen.chi,j goali,j then exit; goals := true;end;Procedure trace;Var i,j : byte;begin writeln(closed = ,closed, open = ,open, oprater = ,r); for i := 1 to 3 do begin for j := 1 to 3 do if dataop

18、en.chi,j = 0 then write( ) else write(dataopen.chi,j); writeln end; readln;end;Procedure print;Var b : array1.20 of word; i,j : word; k,n : byte;begin n := 0; i := open; while i 0 do begin inc(n); bn := i; i := datai.pnt; end; writeln(Staps : ,n-1:5); for k := n downto 1 do begin for i := 1 to 3 do

19、begin for j := 1 to 3 do if databk.chi,j = 0 then write( ) else write(databk.chi,j); writeln; end; readln; end; halt;end;begin closed := 0; open := 1; with data1 do begin ch := start; y := y1; x := x1; pnt := 0; end; repeat inc(closed); temp := dataclosed; for r := 1 to 4 do if check(r) then begin i

20、nc(open); dataopen := temp; with dataopen do begin chy,x := chty,tx; chty,tx := 0; y := ty; x := tx; pnt := closed; end; trace; if dupe then dec(open) else if goals then print; end; until (closed = open) or (open max-3); writeln(No solution !); readln;end.二、队列与广度优先搜索队列是不同于栈的另一种线性表。在日常生活中，无论是购物、订票或候车

21、都有可能要排队。排队所遵循的原则是“先来先服务”，后来者总是加到队尾，排头者总是先离开队伍。队列就是从日常生活中的排队现象抽象出来的。所谓队列，就是允许在一端进行插入，在另一端进行删除的线性表。允许插入的一端称为队尾，通常用一个队尾指针open指向队尾元素，即open总是指向最后被插入的元素；允许删除的一端称为队首，通常也用一个队首指针closed指向排头元素的前面。初始时closed=open=0（如图）。 显然，在队列这种数据结构中，最先插入在元素将是最先被删除；反之最后插入的元素将最后被删除，因此队列又称为“先进先出”（FIFOfirst in first out）的线性表。与栈相似，队

22、列的顺序存储空间可以用一维数组q1m模拟： Q： 1 m 我们按照如下方式定义队列：Const M = 队列元素的上限；Type Equeue = array1.m of qtype； 队列的类型定义Var qm : equeue; 队列open,closed : integer； 队尾指针和队首指针队列的运算主要有两种1.过程ADD(qm，x，open)在队列qm的尾端插入元素x procedure ADD(var qm : equeue； x : qtype； var open : integer)；begin if open = m then writeln(Overflow) 上溢 e

23、lse begin 后移队尾指针并插入元素x open := open+1; qmopen := x; end; end； 2.过程DEL(qm，y，closed,open)取出qm队列的队首元素y procedure DEL(var qm : equeue；var y : qtype；var closed,open : integer)；begin if closed = open then writeln(underflow) 下溢 else begin 后移队首指针并取出队首元素 closed := closed+1；y := qmclosed； end； end；由于队列只能在一端插入

24、，在另一端删除，因此随着入队及出队运算的不断进行，就会出现一种有别于栈的情形：队列在数组中不断地向队尾方向移动，而在队首的前面产生一片不能利用的空闲存储区，最后会导致当尾指针指向数组最后一个位置（即open = m）而不能再加入元素时，存储空间的前部却有一片存储区无端浪费，这种现象称为“假溢出”。下图给出了一个“假溢出”的示例： m m m Openm Am“假溢出” A4open3 A3closed3 Closed 3 2A2 2 2 1 1A1 1 1 Closed,open Closed 初始时队列空 加入三个元素 删除三个元素队列空 加入m-3个元素队列满closed=open=0 c

25、losed=0 open=3 closed=open=3 closed=3 open=m 为了解决“假溢出”的问题，我们不妨作这样的设想：在队列中，当存储空间的最后一个位置已被使用而要进行入队运算时，只要存储空间第一个位置空闲，便可将元素加入到第一个位置，即将存储空间的第一个位置作为队尾。采用首尾相接的队列结构后，可以有效地解决假溢出的问题，避免数据元素的移动，这就是所谓的循环队列。下图给出了循环队列的结构。循环队列将队列存储空间的最后一个位置绕到第一个位置，形成逻辑上的环状空间，供队列循环使用，循环队列的存取方法亦为“先进先出”。对循环队列操作有以下几种状态：初始时队列空，队首指针和队尾指针

26、均指向存储空间的最后一个位置，即closed = open = m。 入队运算时，尾指针进一，即open := open+1；if open = m+1 then open := 1； 这两条语句可用一条语句替代： open := open mod m + 1； 出队运算时，首指针进一，即 closed := closed+1；if closed = m+1 then closed := 1； 这两条语句可用一条语句替代： closed := closed mod m + 1； 队列空时有closed = open。 队列满时有closed = open mod m + 1。（为了区分队列空和队列满，改用“队尾指针追上队首指针” 这 一特征作为队列满标志。这种处理方法的缺点是浪费队列空间的一个存储单元）循环队列的运算有两种：1.过程ADD2(qm,x,open)在循环队列qm中插入一个新元素x procedure ADD2 (var qm : e