BFS之迷宫问题

迷宫问题一直是BFS的经典问题，之前也做了不少，但是一直都是那种求走的最短次数，今天遇到一题需要把最短路径打印出来。所以就卡住了，看了不少别人的博客，千篇一律地使用模拟队列，可是为什么不直接使用queue呢？？

题目描述：
定义一个二维数组：

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问题求解的模板做了一下，代码如下：

#include<cstdio>
#include<cstring> 
#include<queue>
using namespace std;
struct Maze{
    int x, y;
    int step;
}A;

int map[6][6];
int visited[6][6];

int dir[4][2] = {{1, 0}, {-1, 0}, {0, -1}, {0, 1}};
void Init()
{
    memset(visited, 0, sizeof(visited));
    A.x = 0; A.y = 0;
    A.step = 0;
    visited[0][0] = 1;
}

void BFS()
{
    queue<Maze>q;
    q.push(A);
    while(!q.empty())
    {
        Maze u = q.front(); q.pop();
        if(u.x == 4 && u.y == 4)
        {
            printf("%d\n",u.step);//输出最短路径走的次数
            return; 
        }
        for(int i=0; i<4; i++)
        {
            int dx = u.x + dir[i][0];
            int dy = u.y + dir[i][1];
            if(dx < 0 || dx > 4 || dy < 0 || dy > 4 || map[dx][dy] || visited[dx][dy])
                continue;
            visited[dx][dy] = 1;
            Maze v;
            v.x = dx; v.y = dy;
            v.step = u.step + 1;
            q.push(v); 
        }
    }
}

int main()
{
    for(int i=0; i<5; i++)
    {
        for(int j=0; j<5; j++)
        {
            scanf("%d", &map[i][j]);
        }
    }
    Init();
    BFS();
    return 0;
}

这就是以前经常遇到的水题，求出次数。
但是不会打印路径啊，后来查别人的博客，知道要用一个数组保存每个点的父节点，这就是能够打印路径的关键。最后再用一个DFS打印即可。

#include<cstdio>
#include<cstring> 
#include<queue>
using namespace std;
struct Maze{
    int x, y;
}A;

struct Par{
    int x, y;
};

int map[6][6];
int visited[6][6];
Par par[6][6];//用来保存父节点的数组

int dir[4][2] = {{1, 0}, {-1, 0}, {0, -1}, {0, 1}};
void Init()
{
    memset(par, -1, sizeof(par)); 
    memset(visited, 0, sizeof(visited));
    A.x = 0; A.y = 0;
    visited[0][0] = 1;
    par[0][0].x = 0; par[0][0].y = 0;
}

void BFS()
{
    queue<Maze>q;
    q.push(A);
    while(!q.empty())
    {
        Maze u = q.front(); q.pop();
        if(u.x == 4 && u.y == 4)
        {
            return; 
        }
        for(int i=0; i<4; i++)
        {
            int dx = u.x + dir[i][0];
            int dy = u.y + dir[i][1];
            if(dx < 0 || dx > 4 || dy < 0 || dy > 4 || map[dx][dy] || visited[dx][dy])
                continue;
            visited[dx][dy] = 1;
            Maze v;
            v.x = dx; v.y = dy;
            q.push(v); 
            par[dx][dy].x = u.x;  par[dx][dy].y = u.y;//保存父节点 
        }
    }
}

void DFS(int x, int y)
{
    if(x == 0 && y == 0) return;
    DFS(par[x][y].x, par[x][y].y);
    printf("(%d, %d)\n",par[x][y].x, par[x][y].y);
}

int main()
{
    for(int i=0; i<5; i++)
    {
        for(int j=0; j<5; j++)
        {
            scanf("%d", &map[i][j]);
        }
    }
    Init();
    BFS();
    DFS(4,4);
    printf("(4, 4)\n");
    return 0;
}