ACM基础 BFS入门

// 深度搜索利用队列走迷宫，求最短步数
// 题目大意： 有一个N*M的迷宫，地图上S代表起点，G代表终点，#代表墙无法通过，.代表路
// 求从起点到终点的最短距离，如果无法找到出口则输出not find。

// 例如：
// input:
// 3 2
// S#G
// ...

// output
// 4

// dfs隐式的利用了栈的特点，多次递归与栈一样后入先出
// 而bfs则利用队列，先进先出的搜索

#include <iostream>
#include <cstring>
#include <queue>
#include <string>
using namespace std;
typedef pair<int, int> P;       // 方便
const int INF = 10000000;       // 表示未访问过的点的值
const int MAX_N = 100;          // 最大地图的长宽
char maze[MAX_N][MAX_N + 1];    // 模拟地图
int N, M;                       // 代表N行M列
int sx, sy;                     // S的位置坐标
int gx, gy;                     // G的位置坐标
int d[MAX_N][MAX_N];            // 记录当前步数，为访问过为INF
// 代表上下左右四个方向
int dx[4] = { 1, 0, -1, 0}, dy[4] = { 0, 1, 0, -1};
int bfs();

int main()
{
cin >> N >> M;
for(int i = 0; i < N; i++)
{
string str;
cin >> str;
for(int j = 0; j < M; j++)
{
maze[i][j] = str[j];
if(maze[i][j] == 'S')       // 找到起点位置
{
sx = i;
sy = j;
}
if(maze[i][j] == 'G')       // 找到结束位置
{
gx = i;
gy = j;
}
}
}

int ans = bfs();
if(ans == INF)
cout << "can't find " << endl;
else
cout << ans << endl;

return 0;
}

// 返回(sx,sy)到(gx,gy)的最短距离
// 如果无法到达，则返回INF
int bfs()
{
// 创建队列，用于存放坐标点
queue<P> que;
// 初始化d数组
for(int i = 0; i < N; i++)
for(int j = 0; j < M; j++)
d[i][j] = INF;
// 将起点加入队列
que.push(P(sx, sy));
// 将起点的距离设为0
d[sx][sy] = 0;
// 如果队列的长度为0则结束循环
while(que.size())
{
P p = que.front();  // 取出队列最前端的元素
que.pop();          // 弹出队列最前端的元素
if(p.first == gx && p.second == gy)     // 如果取出的元素是终点，则退出循环
break;

// 四方向循环判断，顺序为右下左上
for(int i = 0; i < 4; i++)
{
int nx = p.first + dx[i], ny = p.second + dy[i];
// 判断该位置是否可以移动即是否访问过
if(nx >= 0 && nx < N && ny >= 0 && ny < M && maze[nx][ny] != '#' && d[nx][ny] == INF)
{
// 如果符合条件则加入队列，并且该位置的距离加1
que.push(P(nx, ny));
d[nx][ny] = d[p.first][p.second] + 1;
}
}
}

// 返回终点所需的步数
return d[gx][gy];
}