c++广度优先搜索迷宫问题代码并展示搜索实现的过程

以下是C++实现迷宫广度优先搜索的代码，并展示搜索实现的过程：

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

const int MAXN = 1005;
int maze[MAXN][MAXN]; // 迷宫
int vis[MAXN][MAXN]; // 标记数组
int n, m; // 迷宫的行数和列数

struct Node {
    int x, y; // 当前节点的横纵坐标
    int step; // 到达当前节点的步数（即路径长度）
};

// 判断是否越界或者是否遇到障碍物
bool check(int x, int y) {
    if (x < 1 || x > n || y < 1 || y > m)
        return false;
    if (maze[x][y] == 1 || vis[x][y] == 1)
        return false;
    return true;
}

// 广度优先搜索
int bfs(Node start, Node end) {
    queue<Node> q;
    q.push(start);
    vis[start.x][start.y] = 1;

    while (!q.empty()) {
        Node cur = q.front();
        q.pop();

        // 到达终点，返回路径长度
        if (cur.x == end.x && cur.y == end.y)
            return cur.step;

        // 否则将当前节点的相邻节点入队
        int dx[4] = {0, 0, 1, -1};
        int dy[4] = {1, -1, 0, 0};
        for (int i = 0; i < 4; i++) {
            int nx = cur.x + dx[i];
            int ny = cur.y + dy[i];
            if (check(nx, ny)) {
                vis[nx][ny] = 1;
                Node next = {nx, ny, cur.step+1};
                q.push(next);
            }
        }
    }
    return -1; // 无法到达终点，返回-1
}

int main() {
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            cin >> maze[i][j];
        }
    }

    Node start = {1, 1, 0}; // 起点
    Node end = {n, m, 0}; // 终点
    int ans = bfs(start, end); // 广度优先搜索
    cout << ans << endl;
    return 0;
}

搜索实现的过程：

1. 定义一个队列 `q`，将起点入队，并将起点标记为已访问。
2. 当队列不为空时，从队头取出一个节点 `cur`。
3. 如果 `cur` 是终点，则返回到达该节点的步数（即路径长度）。
4. 否则，将 `cur` 的相邻节点中未访问的节点入队，并将其标记为已访问。
5. 重复步骤2~4，直到找到终点或者队列为空。
6. 如果无法到达终点，则返回-1。