广度优先搜索---迷宫问题（最短路径长度）

题目：

　　给定一个 n x m大小的迷宫，其中 “*” 代表不可通过的墙壁，而 ’.‘代表平地，S表示起点，T表示终点。移动过程中，如果当前位置是（x,y）（下标从0开始），且每次只能往上下左右四个方向的平地移动，求从起点S到达终点T的最少步数。

.....

.*.*.

.*S*.

.***.

...T*

在上面的样例中，S的坐标为（2,2）,T的坐标为（4,3）。

输入格式：

 第一行给出m,n，表示迷宫的行，列；

 下面每一行给出 n个字符，共 m行；

最后一行给出起点坐标S1,S2，终点坐标T1,T2。

输出格式：

输出从起点S到达终点T的最少步数， 不存在输出 -1。

输入样例 1：

5 5 

.....

.*.*.

.*S*.

.***.

...T*

2 2 4 3

输出样例 1：

11

输入样例 2：

5 5

.....

.*.*.

.*S*.

.***.

...T.

2 2 4 3

输出样例 2：

9

输入样例 3：

5 5

.....

.....

..S..

.....

...T.

2 2 4 3

输出样例 3：

3

直接上代码。。。BFS总的来说，比写的DFS代码多一些，奈何时间复杂度好,并且有模板，不容易出现死循环！！！。

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

const int maxn = 100,INF = 0x3fffffff;
struct Node {
    int x,y;
    int layer = 0;//记录从起点S到达该位置的最少步数（层数） 
} node;
char maze[maxn][maxn];
int m,n,MIN = INF;
int S1,S2,T1,T2;
int X[] = {0,0,1,-1};//控制访问的四个方向,新技能 get !!!
int Y[] = {1,-1,0,0};
bool inque[maxn][maxn] = {false};//标记元素是否已经入队---这样不会改变矩阵原本的状态，新技能get !!!
bool judge(int i,int j) {
    if(i < 0 || j < 0 || i>= m||j>= n || maze[i][j] == '*' || inque[i][j] == true)
        return false;
    return true;
}
void BFS(int i, int j) {
    queue<Node> que;                     //定义队列
    node.x = i,node.y = j,node.layer = 0;
    que.push(node);                          //入队
    inque[i][j] = true;                      //标记已经入队
    while(!que.empty()) {                    //队列非空
        Node top = que.front();              //取出队首元素
        que.pop();                           //队首元素出队
        if(top.x == T1 && top.y == T2) {     //如果能到达终点 T 
            MIN = top.layer;
            break;
        }
        for(int i = 0; i < 4; ++i) {         //访问相邻的四个元素
            int nowI = top.x + X[i];
            int nowJ = top.y + Y[i];
            if(judge(nowI,nowJ)) {
                node.x = nowI,node.y = nowJ,node.layer = top.layer + 1;
                que.push(node);              //入队
                inque[nowI][nowJ] = true;    //标记已经入队
            }
        }
    }
}

int main() {
    cin>>m>>n;
    for(int i = 0; i < m; ++i) {             //初始化迷宫
        for(int j = 0; j < n; ++j)
            cin>>maze[i][j];
    }
    cin>>S1>>S2>>T1>>T2;                     //起点(S1,S2)和终点(T1,T2)
    BFS(S1,S2);　　　　　　　　　　　　　　　　　  //广度优先搜索
    cout<< (MIN <INF? MIN : -1);
    return 0;
}

运行结果 1：

 

 运行结果 2：

 

运行结果 3：