迷宫问题(bfs广度优先搜索)【模板】

最新推荐文章于 2023-04-06 17:17:25 发布

清晨喝碗粥

最新推荐文章于 2023-04-06 17:17:25 发布

阅读量581

点赞数

分类专栏：算法学习文章标签：宽度优先算法 c++ 数据结构图论

本文链接：https://blog.csdn.net/G_matinal/article/details/128666885

版权

算法学习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

利用bfs解决迷宫问题是非常常见的算法，毕竟在迷宫问题上bfs比dfs的效率更高，这里我把我的模板分享给大家，并且用一道例题的形式让大家了解并会用此算法

迷宫问题

小明置身于一个迷宫，请你帮小明找出从起点到终点的最短路程。
小明只能向上下左右四个方向移动。

输入格式：

第一行是两个整数n和m (1≤ m, n ≤100)，表示迷宫的长和宽。接下来是n行，每行m个数字，表示整个迷宫。空地格子用0表示，障碍物用1表示，小明所在起点用3表示，终点用4表示。

输出格式：

如果能够到达终点，输出一个整数，表示小明从起点到目的地所需的最短时间。如果不能到达终点，输出“unreachable”。

输入样例1：

5 5
1 0 1 1 1
1 0 4 1 0
1 0 0 1 0
0 0 0 1 0
1 0 3 0 1

输出样例1：

3

输入样例2：

5 5
3 0 1 1 1
1 0 1 1 0
1 0 1 1 0
0 0 0 1 0
1 0 1 0 4

输出样例2：

unreachable

AC代码（带注释理解）

#include<bits/stdc++.h>
using namespace std;
//G为存储迷宫的图, visit用于判断此路径是否走过(true为走过, false为未走过)
vector<vector<int>>G;
vector<vector<bool>>visit;
//方向数组
vector<pair<int, int>>dirs = { {-1, 0}, {0, 1}, {1, 0}, {0, -1} };
//定义一个结构体方便入队
typedef struct point{
    int x, y, step;
}point;
//广度优先搜索
int bfs(int x, int y, int p, int q) {
    point start;
    start.x = x;
    start.y = y;
    start.step = 0;
    queue<point>Q;
    //将起点入队
    Q.push(start);
    while (!Q.empty()) {
        //如果在搜索的过程中到达了终点则立即返回
        if (Q.front().x == p && Q.front().y == q) {
            return Q.front().step;
        }
        int new_x, new_y;
        //这里将以队首元素的(x, y)为中心的周围四个区域依次进行bfs遍历
        for (auto& dir : dirs) {
            new_x = Q.front().x + dir.first;
            new_y = Q.front().y + dir.second;
            //如果该点在图的范围内
            if (new_x >= 0 && new_x < G.size() && new_y >= 0 && new_y < G[0].size()) {
                //如果此刻走的是为走过的路程以及这一块是空地或终点可进行bfs入队
                if ((G[new_x][new_y] == 4 || G[new_x][new_y] == 0) && visit[new_x][new_y] == false) {
                    point temp;
                    temp.x = new_x;
                    temp.y = new_y;
                    temp.step = Q.front().step + 1;
                    Q.push(temp);
                    //将走过的路设置为已走过
                    visit[new_x][new_y] = true;
                }
            }
        }
        Q.pop();
    }
    //若永远也到达不了终点则返回-1
    return -1;
}
int main()
{
    int i, j, n, m, start_x, start_y, p, q;
    cin >> m >> n;
    G.resize(m, vector<int>(n, 0));
    visit.resize(m, vector<bool>(n, false));
    for (i = 0; i < m; i++) {
        for (j = 0; j < n; j++) {
            cin >> G[i][j];
            if (G[i][j] == 3) {
                start_x = i;
                start_y = j;
            }
            if (G[i][j] == 4) {
                p = i;
                q = j;
            }
        }
    }
    //调用bfs之前优先把起点设为已走过
    visit[start_x][start_y] = true;
    int res = bfs(start_x, start_y, p, q);

    if (res == -1)
        cout << "unreachable" << endl;
    else
        cout << res << endl;

    return 0;
}

注：在一部分题目中，空地可能会有时间限制，也就是说想要走过那一片空地是需要一定时间，这类迷宫问题为有权重类迷宫问题，此类问题只需要修改bfs里的队列为优先队列(priority_queue)即可，并根据题干要求对优先队列内的子成员step进行排序即可