迷宫问题

迷宫问题

给定一个 n×n 的二维数组，如下所示：
int maze[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,
};
它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。数据保证至少存在一条从左上角走到右下角的路径。

输入格式
第一行包含整数 n。
接下来 n 行，每行包含 n个整数 0 或 1，表示迷宫。

输出格式
输出从左上角到右下角的最短路线，如果答案不唯一，输出任意一条路径均可。按顺序，每行输出一个路径中经过的单元格的坐标，左上角坐标为 (0,0)，右下角坐标为 (n−1,n−1)。

数据范围
0≤n≤1000
输入样例：
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
输出样例：
0 0
1 0
2 0
2 1
2 2
2 3
2 4
3 4
4 4

Solutions

用于查找从迷宫右下角到左上角的最短路径。

代码读取迷宫 n 的维度和迷宫本身作为一组整数。 迷宫表示为整数 g 的二维数组，其中每个整数表示迷宫中的单元格是否被阻塞。 具体来说，如果 g[i][j] 不为零，则单元格被阻塞，否则解除阻塞。

bfs 函数由 main 函数调用，并使用广度优先搜索 (BFS) 算法找到从迷宫右下角到左上角的最短路径。 具体来说，该函数将起始单元格 (x, y) 的坐标作为输入，然后使用队列从该单元格开始执行 BFS。 对于在 BFS 期间访问过的每个单元格，该函数将单元格标记为在二维数组 pre 中访问过，并将前一个单元格的坐标存储在最短路径中。

在 main 函数中，代码初始化一个二维数组 pre 以跟踪最短路径，然后调用 bfs 函数寻找从迷宫右下角到左上角的最短路径。 然后该函数输出最短路径中每个单元格的坐标，从右下角开始到左上角结束。

#include <bits/stdc++.h>

using namespace std;

typedef pair<int, int> PII;

const int N = 1010;

int n;
int g[N][N];
PII pre[N][N];
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};

void bfs(int x, int y) {
    queue<PII> q;
    q.push(make_pair(x, y));
    memset(pre, -1, sizeof pre);
    PII fi(0, 0);
    pre[x][y] = fi;
    while (q.size()) {
        PII t = q.front();
        q.pop();
        for (int i = 0; i < 4; i++) {
            int tx = t.first + dx[i], ty = t.second + dy[i];
            if (tx < 0 || tx >= n || ty < 0 || ty >= n) continue;
            if (g[tx][ty]) continue;
            if (pre[tx][ty].second == -1) {
                q.push(make_pair(tx, ty));
                pre[tx][ty] = t;
            }
        }
    }
}

int main() {
    cin.tie(nullptr);
    cout.tie(nullptr);
    ios::sync_with_stdio(false);
    cin >> n;
    for (int i = 0; i < n; i ++) {
        for (int j = 0; j < n; j++) {
            cin >> g[i][j];
        }
    }
    bfs(n - 1, n - 1);
    PII end(0, 0);
    while (true) {
        cout << end.first << ' ' << end.second << endl;
        if (end.first == n - 1 && end.second == n - 1) break;
        end = pre[end.first][end.second];
    }
    return 0;
}