迷宫问题
给定一个 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;
}