BFS广度优先搜索讲义

常用算法——广度优先搜索

在深度优先搜索算法中，是深度越大的结点越先得到扩展。如果在搜索中把算法改为按结点的层次进行搜索，本层的结点没有搜索处理完时，不能对下层结点进行处理，即深度越小的结点越先得到扩展，也就是说先产生的结点先得以扩展处理，这种搜索算法称为广度优先搜索法。英语中用Breadth-First-Search表示，所以我们也把广度优先搜索法简称为BFS。

1、广度优先搜索的基本思想

从图中某一顶点Vo出发，首先访问Vo相邻的所有未被访问过的顶点V1、V2、……Vt；再依次访问与V1、V2、……Vt相邻的且未被访问过的所有顶点。如此继续，直到访问完图中所有的顶点。

如果用广度优先法对下图中结点进行搜索，从结点V1出发，先搜索处理它的子结点V2和V3，即深度为2的结点；然后搜索深度为3的子结点V4、V5、V6、V7；最后搜索深度为4的结点V8和V9。整个搜索的次序与结点产生的次序完全一致。

2. 广度优先搜索基本算法：

1）从某个顶点出发开始访问，被访问的顶点作相应的标记，并输出访问顶点号；

2）从被访问的顶点出发，依次搜索与该顶点有边的关联的所有未被访问的邻接点，并作相应的标记。

3）再依次根据2）中所有被访问的邻接点，访问与这些邻接点相关的所有未被访问的邻接点，直到所有顶点被访问为止。

3. 广度优先搜索算法框架：

//by virgil

//bfs base

var

q:array[1..maxn] of record v,r:longint..... end; //fifo fa,la:longint; //fifo first/last pointer

procedure insert(a,b....:longint);//入队

begin

inc(la);

with q[la] do

begin v:=a;r:=b.... end

end;

function take:record v,r:longint..... end;//出队

begin

take:=q[fa];

inc(fa);

end;

procedure bfs;

var k:record v,r:longint..... end

begin

repeat

repeat k:=take until k满足限制;

if k是可行解then exit(k);//返回k

扩展k;

//insert所有k的子节点

until fa>la;

exit(no answer);//返回无解

end;

3. 广度优先搜索实例

【倒水问题】

【八数码问题】

八数码难题(Eight-puzzle)。在3X3的棋盘上，摆有8个棋子，在每个棋子上标有1～8中的某一数字。棋盘中留有一个空格。空格周围的棋子可以移到空格中。要求解的问题是，给出一种初始布局(初始状态)和目标布局(目标状态)，找到一种最少步骤的移动方法，实现从初始布局到目标布局的转变。初始状态和目标状态如下：

初始状态目标状态 2 8 3 1 2 3 1 6 4 8 4 7 5 7 6 5

问题分析：

由于题目要找是达到目标的最少步骤，因此可以这样来设计解题的方法：

初始状态为搜索的出发点，把移动一步后的布局全部找到，检查是否有达到目标的布局，如果没有，再从这些移动一步的布局出发，找出移动两步后的所有布局，再判断是否有达到目标的。依此类推，一直到某布局为目标状态为止，输出结果。由于是按移动步数从少到多产生新布局的，所以找到的第一个目标一定是移动步数最少的一个，也就是最优解。

建立产生式系统：

综合数据库。用3X3的二维数组来表示棋盘的布局比较直观。我们用Ch[i,j]表示第i行第j 列格子上放的棋子数字，空格则用0来表示。为了编程方便，还需存储下面3个数据：该布局的空格位置(Si，Sj)；初始布局到该布局的步数，即深度dep；以及该布局的上一布局，即父结点的位置(pnt)。这样数据库每一个元素应该是由上述几个数据组成的记录。

在程序中，定义组成数据库元素的记录型为：

Type

node＝record

ch：array[1..3，1..3] of byte；{存放某种棋盘布局}

si,sj:byte；{记录此布局中空格位置}

dep,pnt：byte；

end；

因为新产生的结点深度(从初始布局到该结点的步数)一般要比数据库中原有的结点深度大(或相等)。按广度优先搜索的算法，深度大(步数多)的结点后扩展，所以新产生的结点应放在数据库的后面。而当前扩展的结点从数据库前面选取，即处理时是按结点产生的先后次序进行扩展。这样广度优先搜索的数据库结构采用队列的结构形式较合适。我们用记录数组data来表示数据库，并设置两个指针：Head为队列的首指针，tail为队列的尾指针。

产生规则：

原规则规定空格周围的棋子可以向空格移动。但如果换一种角度观察，也可看作空格向上、下、左、右4个位置移动，这样处理更便于编程。设空格位置在(Si，sj)，则有4条规则：

①空格向上移动：if si-1>=1 then ch[si,sj]:=ch[si-1,sj]；ch[si-1,sj]:=0

②空格向下移动：if si+1<=3 then [si,sj]:=ch[si+1,sj]；ch[si+1,sj]:=0

③空格向左移动：if sj-1<=1 then [si,sj]:=ch[si,sj-1]；ch[si,sj-1]:=0

④空格向右移动：if sj+1<=3 then [si,sj]:=ch[si,sj+1]；ch[si,sj+1]:=0

我们用数组Di和Dj来表示移动时行列的增量，移动后新空格的位置可表示为：

nx:=si+di(r)

ny:=sj+dj(r)

其中，r=1,2,3,4为空格移动方向，且r 1 2 3 4 方向左上右下di 0 -1 0 1 dj -1 0 1 0

搜索策略：

按照问题分析中提出的方法，算法设计如下：

程序中新布局与队列中已有布局是否重复，用dup函数检查；找到目标结点后，print过程负责打印出从初始态到目标态移动时各步的布局，buf[n)是用来存放待输出的布局在队列中的位置。

procedure print；

根据上述算法编制的程序如下：

program num8_str1；

uses Crt；

type a33：array[1..3，1..3] Of byte；

{3X3的二维数组，用于存放棋盘布局}

a4=array[1..4] of shortint;

node=record {定义数据库中每个元素记录类型结构}

ch: a33;

si, sj: byte;

pnt, dep: byte;

end;

const goal:a33 = ((1,2,3), (8,0,4), (7,6,5)); {目标布局}

start:a33 =((2,8,3), (1,6,4), (7,0,5)); {初始布局}

di:a4=(0,-1, 0, 1);

dj:a4=(-1, 0, 1, 0);

var data:array[1..100] of node;

temp: node;

r, k, ni, nj, Head, Tail, depth: integer;

{变量depth存放当前搜索深度}

function check(k: integer) :boolean; { 检查某步移动是否可行}

begin

hi:=temp.si+di[k] ; nj:=temp.sj+dj[k];

if (ni in [1..3]) and (nj in [1..3]) {~移动后新位置仍在棋盘中}

then check:=true else check:= false;

end;

function dupe: boolean; { 检查队尾新存入布局是否已在队列中存在} var i,j, k: integer;

buf:boolean;

Begin

buf:= false; i: = 0;

{变量将i依次指向队列中的各个布局(最后一个除外)的位置}

repeat

inc(i) ;buf:= true;

for j:=1 to 3 do

for k:=1 to 3 do

if data[i].ch[j,k] < >data[tail].ch[j,k]

{data[tail]是队列中最后一个元素，即新产生的布局}

then bur:= false;

until buf or (i> = tail-1);

{buf=truee新布局与队列中布局有重复}

dupe:= buf

end;

function goals: boolean; { 比较是否达到目标布局状态}

var i,j :byte;

begin

goals:= true;

for i:=1 to 3 do

for j:=1 to 3 do

if data[tail].ch[i,j] < >goa1[i,j]

then goals:=false {未达到目标布局}

end;

procedure trace;

var i,j :byte;

begin

write( 'cl=', Head,' op=', tail);

writeln('dep=',depth,'k=',k);

fori:=1 to 3 do

begin

for j:= 1 to 3 do write(data[tail], ch[i,j]);

writeln end;

end;

procedure print; {输出移动步骤}

var buf: array[1..100] of integer;

{数组buf存放起始态、目标态以及从起始态到目标态所经过的各态的位置} i,j, k, n: integer;

begin

n:= 1;

i:= tail;buf[1]:= i; {buf[1]中是目标布局在队列中位置}

repeat

j:=data[i].pnt; {data[I].pnt的值是布局I的父结点的位置}

inc(n); buf[n]:=j; i:=j

until i=0; {根结点(初态)的父结点为0，即I=0}

writeln(' staps:', depth + 1);

for i:= 1 to 3 do {打印棋盘布局}

begin

for k:=n-1 down to 1 do

begin

for j:= 1 to 3 do write(data[buf[k]].ch[i,j]);

if i = 2 then write( ' - > ') else write(' ');

end;

writeln;

end;

readln; halt

end;

{ main program = }

begin

Head:= 0; tail:= 1;

with data[1] do {队列中存入第一个元素(初始状态)} begin ch:= start; si:= 3; sj:= 2;

pnt:= 0; dep:= 0;

end;

repeat

inc(Head);temp:=data[Head]; {取队首记录}

depth:= temp.dep;

for r:= 1 to 4 do {对取出记录进行扩展}

if check(r) then {布局中空格向某方向移动成功} begin

inc(tail);data[tail]:= temp; {新产生布局存入队尾} with data[tail] do

begin ch[si,si]:= ch[nj,nj];

ch[ni,nj]:=0;si:=nj;si:=nj;

pnt:=Head;{记录此布局的上一布局在队列中的位置} dep:= depth + 1;{记录本布局的搜索深度}

end;

trace;

if dupe then dec(tail) {dec(tail删除新产生的结点)} else if goals then print;

end;

until Head>=tail; {队列空}

writeln('no solution');readln

end

运行结果：

283 283 283 023 123 123

164—>104—>184—>184—>084—>804

705 765 765 765 765 765

【问题】瑰丽的华尔兹

你跳过华尔兹吗？当音乐响起，当你随着旋律滑动舞步，是不是有一种漫步仙境的惬意？

众所周知，跳华尔兹时，最重要的是有好的音乐。但是很少有几个人知道，世界上最伟大的钢琴家一生都漂泊在大海上，他的名字叫丹尼·布德曼·T.D.·柠檬·1900，朋友们都叫他1900。

1900出生于20世纪的第一年出生在往返于欧美的邮轮弗吉尼亚号上，然后就被抛弃了。1900刚出生就成了孤儿，孤独的成长在弗吉尼亚号上，从未离开过这个摇晃的世界；也许是对他命运的补偿，上帝派可爱的小天使艾米丽照顾他。

可能是天使的点化，1900拥有不可思议的钢琴天赋，从未有人教，从没看过乐谱，但他却能凭着自己的感觉弹出最沁人心脾的旋律。当1900的音乐获得邮轮上所有人的欢迎时，他才8岁，而此时他已经乘着海轮往返欧美50多次了。

虽说是钢琴奇才，但1900还是个8岁的孩子，他有着和一般男孩一样的好奇的调皮，不过可能更有一层浪漫的色彩罢了：

这是一个风雨交加的夜晚，海风卷起层层巨浪拍打着弗吉尼亚号，邮轮随着巨浪剧烈的摇摆。船上的新萨克斯手迈克斯·托尼晕船了，1900将他邀请到舞厅，然后——，然后松开了固定钢琴的闸，于是，钢琴随着海轮的倾斜滑动起来。准确的说，我们的主角1900、钢琴、邮轮随着1900的旋律一起跳起了华尔兹，所有的事物好像都化为一体，随着“强弱弱”的节奏，托尼的晕船症也奇迹般地一点一点恢复。正如托尼在回忆录上这样写道：

大海摇晃着我们

使我们转来转去

快速的掠过灯和家具

我意识到我们正在和大海一起跳舞

真是完美而疯狂的舞者

晚上在金色的地板上快乐的跳着华尔兹是不是很惬意呢？也许，我们忘记了一个人，那就是艾米丽，她可没闲着：她必须在适当的时候施魔法帮助1900，不让钢琴碰上舞厅里的家具。而艾米丽还小，她无法施展魔法改变钢琴的运动方向或速度，而只能让钢琴停一下。

不妨认为舞厅是一个N行M列的矩阵，矩阵中的某些方格上堆放了一些家具，其他的则是空地。钢琴可以在空地上滑动，但不能撞上家具或滑出舞厅，否则会损坏钢琴和家具，引来难缠的船长。

每个时刻，钢琴都会随着船体倾斜的方向向相邻的方格滑动一格，其中相邻的方格可以是向东、向西、向南或向北的。而艾米丽可以选择施魔法或不施魔法，如果不施魔法，则钢琴会滑动，而如果施魔法，则钢琴会原地不动。

艾米丽是个天使，她知道每段时间的船体的倾斜情况。她想使钢琴尽量长时间在舞厅里滑行，这样1900会非常高兴，同时也有利于治疗托尼的晕船。但艾米丽还太小，不会算，所以希望你能帮助她。

【输入格式】

输入文件的第一行包含5个数N, M, x, y和K。N和M描述舞厅的大小，x和y为在第1时刻初钢琴的位置（x行y列）；我们对船体倾斜情况是按时间的区间来描述的，比如“在[1, 3]时间里向东倾斜，[4, 5]时间里向北倾斜”，因此这里的K表示区间的数目。

以下N行，每行M个字符，描述舞厅里的家具。第i行第j列的字符若为‘ . ’，则表示该位置是空地；若为‘ x ’，则表示有家具。

以下K行，顺序描述K个时间区间，格式为：si ti di(1 ≤ i ≤ K)。表示在时间区间[si, ti]内，船体都是向di方向倾斜的。di为1, 2, 3, 4中的一个，依次表示北、南、西、东（分别对应矩阵中的上、下、左、右）。输入保证区间是连续的，即

s1 = 1

ti = si-1 + 1 (1 < i ≤ K)

tK = T

【输出格式】

输出文件仅有1行，包含一个整数，表示钢琴滑行的最长距离(即格子数)。

【输入样例】

4 5 4 1 3

..xx.

.....

...x.

.....

1 3 4

4 5 1

6 7 3

【输出样例】

6

【评分方法】

本题没有部分分，你的程序的输出只有和我们的答案完全一致才能获得满分，否则不得分。

【数据范围】

50%的数据中，1≤N, M≤200，T≤200；

100%的数据中，1≤N, M≤200，K≤200，T≤40000。