迷宫问题 POJ

定义一个二维数组：

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 <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <queue>

using namespace std;
const int N = 1e2;

struct node
{
    int x, y, step;
}path[N][N];    //保存路径
int map[N][N];
bool vis[N][N];
int xx[4] = {1, 0, 0, -1};
int yy[4] = {0, 1, -1, 0};

void print(int i, int j)
{
    if(i == 0 && j == 0)
        return;
    print(path[i][j].x, path[i][j].y); //递归打印路径
    printf("(%d, %d)\n", i, j);
}
void BFS()
{
    queue<node> q;
    struct node t, tp;
    memset(vis, 0, sizeof(vis));
    t.x = 0;
    t.y = 0;
    t.step = 0;
    q.push(t);
    vis[0][0] = 1;
    while(!q.empty())
    {
        tp = q.front();
        q.pop();
        if(tp.x == 4 && tp.y == 4)
        {
            printf("(0, 0)\n");
            print(4, 4);
            return;
        }
        for(int i = 0; i < 4; i++)
        {
            if(tp.x + xx[i] >=0 && tp.x + xx[i] < 5 && tp.y + yy[i] >=0 && tp.y + yy[i] < 5)
            {
                if(map[tp.x + xx[i]][tp.y + yy[i]] == 0)
                {
                    t.x = tp.x + xx[i];
                    t.y = tp.y + yy[i];
                    t.step = tp.step + 1;
                    q.push(t);
                    vis[t.x][t.y] = 1;
                    path[t.x][t.y].x = tp.x; //存坐标
                    path[t.x][t.y].y = tp.y;
                }
            }
        }
    }
}

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