用广度优先搜索探索迷宫问题

前面我们已经学会了如何用dfs解决迷宫最短路问题。用dfs求解迷宫有一个很大的缺点，需要枚举所有可能的路径，读入的地图一旦很大，可能的搜索方案数量会非常多，用dfs搜索显然效率非常低。
我们可以借助bfs来求解迷宫问题。由于bfs时分层搜索，因此，第一次搜索到终点的时候，当前搜索的层数就是最短路径的长度。

先输入行数n和列数m，在输入每个位置的信息，“S”代表当前位置为起点，“T"代表这个位置为终点，”C”代表当前位置可以走， *“表示当前位置是墙，求最少多少步可以到达终点。

为了记录一个状态，首先我们要定义一个结构体，用这个结构体来记录一个状态，这个结构体需要记录坐标x，y以及当前所用的步数d。
我们在这个结构体中加上一个构造函数，构造函数可以使后续在队列放入元素变得更简洁。
bfs函数传入两个参数sx和sy，表示起点坐标，在bfs开头先定义一个队列，然后把起点压入队列，并且标记起点为已访问状态，这里借助构造函数node(sx,sy,0)快速插入一个结构体。
当队列中有元素的时候，我们先取出队首的元素。
用我们从队列中取出点去扩展其他的点。如果当前位置合法且没被访问，如果是终点，那么就可以直接返回了，如果不是终点，把这个点标记为已访问，并且压入队列。
如果无法通过BFS能访问到终点，则返回-1，表示没有找到一条可以从起点到终点的路径，自然也就不存在最短路了。
最后，我们只需要写读入和在main函数中调用bfs函数即可。

示例代码：

#include <iostream>
#include <string>
#include <queue>
using namespace std;
int n, m;
string maze[110];
bool vis[110][110];
int dir[4][2] = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};
bool in(int x, int y) {
    return 0 <= x && x < n && 0 <= y && y < m;
}
struct node{
    int x,y,d;
    node(int xx,int yy,int dd){
        x=xx;
        y=yy;
        d=dd;
    }
};
int bfs(int sx,int sy){
    queue<node> q;
    q.push(node(sx,sy,0));
    vis[sx][sy]=true;
    while(!q.empty()){
        node now=q.front();
        q.pop();
        for(int i=0;i<4;i++){
            int tx=now.x+dir[i][0];
            int ty=now.y+dir[i][1];
            if(in(tx,ty) && maze[tx][ty]!='*' && !vis[tx][ty]){
                if(maze[tx][ty]=='T'){
                    return now.d+1;
                }else{
                    vis[tx][ty]=true;
                    q.push(node(tx,ty,now.d+1));
                }
            }
        }
    }
     return -1;
}
int main() {
    cin >> n >> m;
    for (int i = 0; i < n; i++) {
        cin >> maze[i];
    }
    int x, y;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (maze[i][j] == 'S') {
                x = i, y = j;
            }
        }
    }
    cout<<bfs(x,y)<<endl;
    return 0;    
}