论深度优先（DFS）和广度优先搜索（BF）的优点及不足（更新ing）
例题：
POJ 1915 Knight Moves 骑士遍历问题(跳马问题)
在一个m*m的棋盘上，从任意一个给定的位置(sx , sy)出发，为象棋中的马找一条路通过最少的步数到达另一位置(ex ,ey)，输出最少所需要的步数。
利用bfs求解。
当马在位置(x , y)的时候其后继节点(后继选择)是什么？
对于马，有八个方向可以选择，马可以跳到如下几个位置：
(x+2 , y+1) ,
(x+1 , y+2 ) ,
(x-1 , y+2) ,
(x-2 , y+1)，
(x+2 , y -1) ,
(x+1 , y-2 ) ,
(x-1 , y-2) ,
(x-2 , y-1)；
那么后继状态也就是这些可选的位置了。
当然要判断这些后继位置是否会越界，去掉那些会越界的节点。
Sample Input
3 8 0 0 7 0 100 0 0 30 50 10 1 1 1 1
Sample Output
5 28 0
/*Knight Moves*/
#include <iostream>
#include <cstdio>
using namespace std;
struct Node
{
int x ;
int y ;
int d ;
void init(int nx , int ny , int nd)
{
x = nx ;
y = ny ;
d = nd ;
}
};
bool visit[MAXN][MAXN];
int bfs(Node source , Node target){
queue<Node> Q ;
source.d = 0 ;
Q.push(source);
memset(visit , 0 , sizeof(visit)) ;
visit[source.x][source.y] = 1 ;
while(!Q.empty()){
Node a = Q.front() ;
Q.pop() ;
int x = a.x ;
int y = a.y ;
for(int i = 0 ; i < 8 ; i ++){
int nx = x + dir[i][0] ;
int ny = y + dir[i][1] ;
//判断新的节点是否会越界
if(nx < 0 || nx >= m || ny >= m || ny < 0)
continue ;
if(visit[nx][ny])
continue ;
//判断后继节点是否是目标节点
if(target.x == nx && target.y == ny)
return a.d + 1 ;
visit[nx][ny] = 1 ;
Node c ;
c.init(nx , ny , a.d + 1) ;
Q.push(c) ;
}
}
return -1 ;
}
//////////////////////////////////////////////////////////////////////////////////////////////
AC代码：
#include<iostream> using namespace std; const int Max = 305; struct{ int r, c; }sta, end, queue[Max * Max]; int len; bool vis[Max][Max]; int dr[8] = {-2, -2, -1, -1, 1, 1, 2, 2}; int dc[8] = {-1, 1, -2, 2, -2, 2, -1, 1}; bool inmap(int r, int c){ if(r >= 0 && r < len && c >= 0 && c < len) return true; return false; } int main(){ int n; cin >> n; while(n --){ cin >> len; cin >> sta.r >> sta.c >> end.r >> end.c; if(sta.r == end.r && sta.c == end.c){ // 记得加起点等于终点的判断。 cout << '0' << endl; continue; } memset(vis, false, sizeof(vis)); vis[sta.r][sta.c] = true; queue[0].r = sta.r; queue[0].c = sta.c; int head = 0, tail = 1, steps = 0; bool find = false; while(!find){ steps ++; int count = tail - head; while(!find && count --){ for(int i = 0; i < 8; i ++){ int r = queue[head].r + dr[i]; int c = queue[head].c + dc[i]; if(r == end.r && c == end.c){ find = true; break; } if(inmap(r, c) && !vis[r][c]){ vis[r][c] = true; queue[tail].r = r; queue[tail].c = c; tail ++; } } head ++; // 一开始把head++写到外面，卡了很久，以后要小心。 } } cout << steps << endl; } return 0; }
评价：
这份代码的优点很明显。相对与深度优先搜索来说，它只要每次访问一个层次，不会造成较大的空间浪费。
然后就是理解起来相对较为方便，只要搞清楚基本的思路和队列的用法，基本上磨磨蹭蹭的搞个几小时基本还是能够将结果返回出来的。