迷宫问题 - POJ - 3984 （广搜 + 路径记录)

迷宫问题 - POJ - 3984 （广搜 + 路径记录）

POJ-3984:原题链接，点击进入

***心态炸裂，很气，这道题的写广搜一会就完成了，但是路径记录今天几乎卡了我一天，一直想不通怎么实现不重复记录走过的点，最后在大佬的提示和网上的资料的帮助下，终于解决了！！！哦对了，据说这题后台样例只有一组，还是题上给出的，所以直接暴力解决更快哦，哈哈哈哈哈哈……^_^ ***

问题描述：

定义一个二维数组：

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)

思路：

看到最短路径，第一时间想到的就是BFS,但是这道题不是让我们输出最短的路径是多少，而是走出迷宫的最短路径所经过的点，所以在BFS的基础上，还应该加上记录路径。这里我使用的是从终点开始一次将每一个点的前一个点放入stack中，由于stack有FILO的特点，所以当找到起点后，依次弹栈就是走出迷宫的最短路径所经过的点。

*这里有个坑，输出的时候，如(0, 1)这种，每个坐标的第一个数字后面有一个空格，
输出的时候一定要注意！！！！！*

上代码！

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<stack>
#include<queue>
using namespace std;
const int maxn = 1e3 + 5;
int len = 1;
int a[5][5];
int vis[5][5]; //标记数组
int dir[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
int mark[6][6];
struct node
{
    int a;
    int b;
    int steps;
    int pre;//记录前一个点的序号
    int now;//记录当前这个节点的序号
    friend bool operator<(node x, node y)
    {
        return x.steps > y.steps;
    }
} p, road[50];
void pointout(int now)
{
    int index = now;
    stack<node> stk;
    while (index != -1){
        stk.push(road[index]);
        index = road[index].pre;
    }
    while (!stk.empty()){
        printf("(%d, %d)\n",stk.top().a,stk.top().b);
        stk.pop();
    }
}
void init()
{
    for (int i = 0; i < 5; i++){
        for (int j = 0; j < 5; j++){
            a[i][j] = 0;
            vis[i][j] = 0;
        }
    }
}
//左上角到右下角 最短路 bfs
void bfs()
{
    priority_queue<node> q;
    p.a = 0;
    p.b = 0;
    p.steps = 0;
    p.pre = -1;//起点的前一个默认为-1
    p.now = len;//起点的序号是1
    vis[0][0] = 1;
    q.push(p);
    road[len++] = p;
    while (!q.empty()){
        p = q.top();
        q.pop();
        //到达终点 进行回溯
        if(p.a == 4 && p.b == 4){
            pointout(p.now);
            return ;
        }
        node next;
        for (int i = 0; i < 4; i++){
            int nx = p.a + dir[i][0];
            int ny = p.b + dir[i][1];
            if (a[nx][ny] != 1 && vis[nx][ny] != 1 && nx >= 0 && nx < 5 && ny >= 0 && ny < 5){
                //记录当前可以走的下一个点的坐标
                vis[nx][ny] = 1;
                next.a = nx;
                next.b = ny;
                next.pre = p.now;
                next.now = len;
                next.steps = p.steps + 1;
                road[len++] = next;
                q.push(next);
            }
        }
        
    }
}
int main()
{
    init();
    for (int i = 0; i < 5; i++){
        for (int j = 0; j < 5; j++){
            scanf("%d",&a[i][j]);
        }
    }
    bfs();
    return 0;
}