宽度优先搜索

给定大小为N*M的迷宫，求出起点到终点的最小步数。

输入

输出

22

#include <iostream>
#include <fstream>
#include <queue>
using namespace std;

#define MAX_N 100
#define MAX_M 100

const int INF = 100000000;

//pair<int,int>表示坐标状态
typedef pair<int, int> P;

//输入
char maze[MAX_N][MAX_M];  //表示迷宫字符串数组
int N, M;
int sx, sy;   //起点坐标
int gx, gy;   //终点坐标

int d[MAX_N][MAX_M];    //到各个位置的作短距离

//4个方向移动的向量
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};


//求从(sx, sy)到(gx, gy)的最短距离
//如无法到达，则是INF
int BFS()
{
    queue<P> que;
    //把所有位置的距离都初始化为INF
    for (int i = 0; i < N; i++)
        for (int j = 0; j < M; j++)
            d[i][j] = INF;
    //将起点加入队列，并把距离设为0
    que.push(P(sx, sy));
    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 (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;
            }
        }
    }
    return d[gx][gy];
}

int main()
{
    ifstream cin("input");

    cin >> N >> M;

    for (int i = 0; i < N; i++)
        for (int j = 0; j < M; j++)
        {
            cin >> maze[i][j];
            if (maze[i][j] == 'S')
            {
                sx = i;
                sy = j;
            }
            else if (maze[i][j] == 'G')
            {
                gx = i;
                gy = j;
            }
        }

    cout << BFS() << endl;

    return 0;
}