BFS(宽搜）思路+样题走迷宫

宽搜可以搜到最短路

宽搜是一层一层来搜

第一层是搜索所以距离为1的点

第二层是搜索所以距离为2的点

.....以此类推，第一层就是最短路径

图来源:acwing:Hasity

题目：走迷宫

活动 - AcWing

给定一个 n×m的二维整数数组，用来表示一个迷宫，数组中只包含 0或 1，其中 0

表示可以走的路，1

表示不可通过的墙壁。

最初，有一个人位于左上角 (1,1)处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。

请问，该人从左上角移动至右下角 (n,m)处，至少需要移动多少次。数据保证 (1,1)处和 (n,m) 处的数字为 0

，且一定至少存在一条通路。

输入格式

第一行包含两个整数 n和 m。接下来 n 行，每行包含 m个整数（0或 1），表示完整的二维数组迷宫。

输出格式

输出一个整数，表示从左上角移动至右下角的最少移动次数。

数据范围

1≤n,m≤100

输入样例：

5 5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

输出样例：

8

思想

BFS走迷宫的思想，每次把所有可以走的方向都走了

然后在一个队列中存储所有准备走下一步的坐标

走完之后，把坐标在队列中删除，对走过的路径进行标记

等到队列中没有坐标，说明所有可走的坐标已经走完

用一个数组f[][]记录每个坐标走到时的长度

输出f[n][m]表示最短距离

为什么就算有多条通路，它总能输出最小距离？

因为当第一个点到达终点时，它一定是最短距离，并且会将终点变成墙

那么其他点再也无法到达终点，也更新不了初始点到终点的距离。

#include <cstring>
#include <iostream>
#include <queue>
using namespace std;
typedef pair<int, int> PII;
const int N = 110;
int g[N][N];//存储地图
int f[N][N];//存储距离
int n, m;
void bfs(int a, int b)//广度优先遍历,a,b,代表坐标
{
    //定义一个队列
    queue<PII> q;
    //读入坐标
    q.push({a, b});
    //初始点的距离为 0.
    //可以不要这一句，因为f初始化的时候，各个点为距离0
    f[0][0] = 0;
    //判断队列数组是否为空，为空表示走完所有地图了
    //不是找到答案停止循环，而是走完地图所有可到区域停止循环
    while(!q.empty())
    {
        //queue先进先出
        //start存储了当前坐标信息，然后利用start向上下左右方向走
        //并把走到的位置坐标存储在队列中，把当前坐标信息删除
        //队列中只保存需要往其他方向走的坐标信息
        PII start = q.front();//返回队头元素，队头元素是一个坐标
        q.pop();//删除队头
        //设置坐标为的g[x][y]值为1，表示走过
        //这一句可以不要，因为入队的时候就置为了1
        g[start.first][start.second] = 1;
        //定义方向偏移量，上下左右
        //把dy想成i,dy想成j,是一个i,j矩阵[i][j]
        int dx[4] = {-1, 1, 0, 0}, dy[4] = {0, 0, -1, 1};
        for(int i = 0; i < 4; i++)//往四个方向走
        {
            //当前点能走到的点
            //start.first是i坐标， start.second是j坐标
            int x = start.first + dx[i], y = start.second + dy[i];
            //如果还没有走过，并且合法（不合法为-1）
            if(g[x][y] == 0)
            {
                //走到这个点，标记已经走过
                g[x][y] = 1;
                //计算距离，上个坐标+1，即是起点到这的距离
                f[x][y] = f[start.first][start.second] + 1;//从当前点走过去，则距离等于当前点的距离+1.
                //这个点放入队列，用来走到和它相邻的点。
                q.push({x, y});
            }

        }
    }
//为什么就算有多条通路，它总能输出最小距离？
//因为当第一个点到达终点时，它一定是最短距离，并且会将终点变成墙
//那么其他点再也无法到达终点，也更新不了初始点到终点的距离。
    cout << f[n][m];
}

int main()
{
    //初始化越界后其他范围内都是-1,表示越界，不合法
    memset(g, -1, sizeof(g));
    cin >> n >>m;
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            cin >> g[i][j];//只有读入新的值，非-1，才合法
        }
    }
    bfs(1,1);

}