给定一个大小为N*M的迷宫,由通道('.')和墙壁('#')组成,其中通道S表示起点,通道G表示终点,每一步移动可以达到上下左右中不是墙壁的位置。试求出起点到终点的最小步数。(本题假定迷宫是有解的)
(N,M<=100)
样例输入:
10 10
# | S | # | # | # | # | # | # | . | # |
. | . | . | . | . | . | # | . | . | # |
. | # | . | # | # | . | # | # | . | # |
. | # | . | . | . | . | . | . | . | . |
# | # | . | # | # | . | # | # | # | # |
. | . | . | . | # | . | . | . | . | # |
. | # | # | # | # | # | # | # | . | # |
. | . | . | . | # | . | . | . | . | . |
. | # | # | # | # | . | # | # | # | . |
. | . | . | . | # | . | . | . | G | # |
样例输出:
22
来自《挑战程序设计竞赛(第2版)》
该题很好地体现了BFS是如何与队列先进先出(FIFO)的思想联系起来的。搜索时先将初始状态添加到队列里,此后从队列的最前端不断取出状态,把从该状态可以转移到的状态中尚未访问过的部分加入队列,如此往复,直到队列被取空或找到了问题的解。总是先搜索距离初始状态近的状态,按照距开始状态由近及远的顺序进行搜索。对于同一个状态只经过1次,复杂度为O(状态数X转移的方式)
对本题,转移的方式为四方向移动,状态数等于迷宫的大小,复杂度为O(4xNxM)=O(NxM)
代码如下:
#include <iostream>
#include <queue>
using namespace std;
const int MAX_N = 100;
const int MAX_M = 100;
const int INF = 0x3f3f3f3f;
typedef pair<int, int> P;
char maze[MAX_N][MAX_M + 1];
int N, M;
int sx, sy; //起点的位置
int gx, gy; //终点的位置
int d[MAX_N][MAX_M];//储存起点到某一点的距离
int dx[4] = { 1,0,-1,0 }, dy[4] = { 0,1,0,-1 }; //表明每次x和y方向的位移
void bfs()
{
queue<P> que;
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++)
d[i][j] = INF; //初始化所有点的距离为INF
que.push(P(sx, sy));
d[sx][sy] = 0; //从起点出发将距离设为0,并放入队列首端
while (que.size()) //题目保证有路到终点,所以不用担心死循环
{
P p = que.front(); que.pop();//弹出队首元素
int i;
for (i = 0; i < 4; i++)
{
int nx = p.first + dx[i];
int ny = p.second + dy[i];//移动后的坐标
//判断可移动且没到过
if (0 <= nx&&nx < N
&& 0 <= ny&&ny < M
&&maze[nx][ny] != '#'
&&d[nx][ny] == INF)//之前到过的话不用考虑,因为距离在队列中递增,肯定不会获得更好的解
{
que.push(P(nx, ny)); //可以移动则设定距离为之前加一,放入队列
d[nx][ny] = d[p.first][p.second] + 1;
if(nx==gx && ny==gy) break;
}
}
if(i!=4) break;
}
}
int main()
{
cin>>N>>M;
for (int i = 0; i < N; i++)
cin>>maze[i];
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++)
{
if (maze[i][j] == 'S')
{
sx = i; sy = j;
}
if (maze[i][j] == 'G')
{
gx = i; gy = j;
}
}
bfs();
cout<<d[gx][gy]<<endl;
return 0;
}