广搜基础 Knight 国际象棋的跳马

BFS ，广度优先搜索，顾名思义，搜索的时候以广度为先，就像是一块石子（搜索的起点）掷向水面，一圈一圈地扩张，每一次扩张，都会有一个层次图，这个层次图大可理解为访问的第几个阶段吧，层次为 2 的点一定比层次为 3 的点先被访问。我感觉DFS也是有层次图的，也就是当前点未来要访问的那些点，就是一个层次，或者理解为递归的同一层。我第一次接触层次图的概念是在 dicnic 算法 。BFS 可以用队列实现。

以下是几个广度优先搜索的例子。

A friend of you is doing research on the Traveling Knight Problem (TKP) where you are to find the shortest closed tour of knight moves that visits each square of a given set of n squares on a chessboard exactly once. He thinks that the most difficult part of the problem is determining the smallest number of knight moves between two given squares and that, once you have accomplished this, finding the tour would be easy. 
Of course you know that it is vice versa. So you offer him to write a program that solves the "difficult" part. 

Your job is to write a program that takes two squares a and b as input and then determines the number of knight moves on a shortest route from a to b.

Input

The input will contain one or more test cases. Each test case consists of one line containing two squares separated by one space. A square is a string consisting of a letter (a-h) representing the column and a digit (1-8) representing the row on the chessboard.

Output

For each test case, print one line saying "To get from xx to yy takes n knight moves.".

Sample Input

e2 e4
a1 b2
b2 c3
a1 h8
a1 h7
h8 a1
b1 c3
f6 f6

Sample Output

To get from e2 to e4 takes 2 knight moves.
To get from a1 to b2 takes 4 knight moves.
To get from b2 to c3 takes 2 knight moves.
To get from a1 to h8 takes 6 knight moves.
To get from a1 to h7 takes 5 knight moves.
To get from h8 to a1 takes 6 knight moves.
To get from b1 to c3 takes 1 knight moves.
To get from f6 to f6 takes 0 knight moves.

做这道题得知道象棋中马是怎么走的，和正常下象棋的走法一样。

#include <iostream>
#include <cstring>
using namespace std ;
int Gragh[9][9] ;
int Queue_x[100] , Queue_y[100] ;
int dx[8] = { 1 , 1 , -1 , -1 , 2 , 2 , -2 , -2 } ;    // 用 dx , dy 数组描述马要走的八个方向，很方便
int dy[8] = { 2 , -2 , 2 , -2 , 1 , -1 , 1 , -1 } ;
int pre[9][9] ;

int BFS( int sx , int sy , int desx , int desy ){
	int front = 0 , rear = 0 ;
	Queue_x[++rear] = sx , Queue_y[rear] = sy ;      // 起点入队列
	pre[sx][sy] = 1 ;                                // 标记起点的层次为 1 ， 同时标记这点搜索过了
	while( front != rear ){
		int curx = Queue_x[++front] , cury = Queue_y[front] ;
		for( int i = 0 ; i < 8 ; ++i ) {
			int x = curx + dx[i] ;                // 获得下一个点的坐标
			int y = cury + dy[i] ;
			if( x < 1  || x > 8 || y < 1 || y > 8 || pre[x][y] ) // 越界或者这个点访问过了
				continue ;
			pre[x][y] = pre[curx][cury] + 1 ;     // 层次+1 ， 扩张
			if( x == desx && y == desy )          // 走到终点 , 返回当前层次需要的步数
				return pre[x][y]-1 ;
			if( x >= 1 && x <= 8 && y >= 1 && y <= 8 )      // 层次图可以继续扩张的入队列
				Queue_x[++rear] = x , Queue_y[rear] = y ;
              }
	}
	return 0 ;
}

int main(){
	string src , des ;
	int sx , sy , desx , desy ;
	while( cin >> src >> des ){
		sx = src[0]-'a'+1 , sy = src[1]-'0' ;
		desx = des[0]-'a'+1 , desy = des[1]-'0' ;
		memset( pre , 0 , sizeof( pre ) ) ;
		cout << "To get from " << src <<" to " << des << " takes " << BFS( sx , sy , desx , desy ) << " knight moves." << endl ;
	}
	return 0 ;
}

主要就是 BFS 建立层次图来确定马需要到达终点的步数 。

Background 
Mr Somurolov, fabulous chess-gamer indeed, asserts that no one else but him can move knights from one position to another so fast. Can you beat him? 
The Problem 
Your task is to write a program to calculate the minimum number of moves needed for a knight to reach one point from another, so that you have the chance to be faster than Somurolov. 
For people not familiar with chess, the possible knight moves are shown in Figure 1.

Input

The input begins with the number n of scenarios on a single line by itself. 
Next follow n scenarios. Each scenario consists of three lines containing integer numbers. The first line specifies the length l of a side of the chess board (4 <= l <= 300). The entire board has size l * l. The second and third line contain pair of integers {0, ..., l-1}*{0, ..., l-1} specifying the starting and ending position of the knight on the board. The integers are separated by a single blank. You can assume that the positions are valid positions on the chess board of that scenario.

Output

For each scenario of the input you have to calculate the minimal amount of knight moves which are necessary to move from the starting point to the ending point. If starting point and ending point are equal,distance is zero. The distance must be written on a single line.

Sample Input

3
8
0 0
7 0
100
0 0
30 50
10
1 1
1 1

Sample Output

5
28
0

#include <iostream>
#include <cstring>
using namespace std ;
const int Max = 301 ;
int radius ;
struct Node{
	int x , y ; 
} Queue[Max*Max];
int pre[Max][Max] ;
int dx[9] = { 1 , 1 , -1 , -1 , 2 , 2 , -2 , -2 } ;
int dy[9] = { 2 , -2 , 2 , -2 , 1 , -1 , 1 , -1 } ;

int BFS( int sx , int sy , int desx , int desy ){
	int front = 0 , rear = 0 ;
	Queue[++rear].x = sx , Queue[rear].y = sy ;
	pre[sx][sy] = 1 ;
	while( front != rear ){
		int curx = Queue[++front].x , cury = Queue[front].y ;
		for( int i = 0 ; i < 8 ; ++i ){
			int x = curx + dx[i] , y = cury + dy[i] ;
			if( x < 0 || x >= radius || y < 0 || y >= radius || pre[x][y] )
				continue ;
			else if( pre[x][y] == 0 )                // 如果这个点没访问过
				Queue[++rear].x = x , Queue[rear].y = y ;
			pre[x][y] = pre[curx][cury] + 1 ;        // 标记层次
			if( x == desx && y == desy )
				return pre[x][y] - 1 ;
		}
	}
	return 0 ;
}

int main(){
	int cases ;
	cin >> cases ;
	while( cases-- ){
		cin >> radius ;
		Node src , des ;
		cin >> src.x >> src.y >> des.x >> des.y ;
		memset( pre , 0 , sizeof( pre ) ) ;
		cout << BFS( src.x , src.y , des.x , des.y ) << endl ;
	}
	return 0 ;
}

这两题思路一样，就是通过 BFS 拓展层次图来确定步数 。

BFS 挺好调试的，不像 DFS 更难改（ 我个人觉得 ）。有些经典算法，就像 Disjkstra 最短路算法，也是 BFS 。