POJ 3984 迷宫问题（BFS记录最短路径）

1. 题意

定义一个二维数组：

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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

Input
一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。

Output
左上角到右下角的最短路径，格式如样例所示。

Sample Input
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

Sample Output
(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)

2. 思路

这道题是道BFS常规题，关键在怎么记录路径

一颗BFS树中，每个节点的后继节点是不固定的，它可能朝着其他方向走

但前驱节点是固定的，所以我们只要想办法记录前驱节点就可以

3. 代码

#include<cstdio>
#include<queue>
#include<iostream>
using namespace std;
struct node {
    int x, y;
};

int N = 5;
node pre[15][15];
int map[15][15];
bool vis[15][15] = {false};
int px[] = {0, 0, -1, 1}, py[] = {1, -1, 0, 0};

bool judge(int nx, int ny) {
    if (nx >= 0 && nx < N && ny >= 0 && ny < N && 
        !vis[nx][ny] && map[nx][ny] == 0) {
        return true;
    }
    return false;
}

void print(node cur) {
    if (cur.x == 0 && cur.y == 0) {
        printf("(0, 0)\n");
        return ;
    }
    
    print(pre[cur.x][cur.y]);
    printf("(%d, %d)\n", cur.x, cur.y);
} 

void bfs(int x, int y) {
    queue<node> q;
    node s;
    s.x = x; s.y = y; vis[x][y] = true;
    q.push(s);
    while(!q.empty()) {
        node t = q.front();
        q.pop();
        if (t.x == N-1 && t.y == N-1) {
            print(t);
            return ;
        }
        for (int i = 0; i < 4; i++) {
            int nx = t.x + px[i];
            int ny = t.y + py[i];
            if (judge(nx, ny)) {
                vis[nx][ny] = true;
                node s;
                s.x = nx; s.y = ny;
                q.push(s);
                pre[s.x][s.y] = t; // 记录前驱节点 
            }
        } 
    }
}

int main() {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            scanf("%d", &map[i][j]);
        }
    }
    bfs(0, 0);
}