迷宫问题

Description
定义一个二维数组：

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)
第一眼看到这个题目的时候，觉得还挺好搞，然后路径就吃屎了。然后用dfs的方法暴力搞，反正5*5.现在想一想，在结构体里加一个数，记录上一个位置，用链表，或者1,2,3,4代表四个方向的操作，都可以，好多方法。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
int a[6][6], dp[30][30], leap[30][30], flag = 0;
int dir[4][2] = { 1, 0, -1, 0, 0, 1, 0, -1 };
struct Node{
    int x;
    int y;
};
queue<Node>p;
void dfs(int x,int y)
{
    int i, tempx, tempy;
    if (x == 1 && y == 1)
    {
        flag = 1;
    }
    else{
        for (i = 0; i < 4; i++)
        {
            tempx = x + dir[i][0]; tempy = y + dir[i][1];
            if (tempx >= 1 && tempy >= 1 && tempx <= 5 && tempy <= 5)
            {
                if (leap[tempx][tempy] && dp[tempx][tempy] == dp[x][y] - 1)
                {
                    dfs(tempx, tempy);
                    if (flag)
                    {
                        cout << "("<<tempx-1 << ", " << tempy-1 <<")"<< endl;
                        return;
                    }
                }
            }
        }
    }
}
int main()
{
    int i, j, m, n, ans;
    Node temp, now;
    for (i = 1; i <= 5;i++)
    for (j = 1; j <= 5; j++)
    {
        cin >> a[i][j];
        leap[i][j] = 0;
    }
    temp.x = temp.y = 1;
    dp[1][1] = 0;
    leap[1][1] = 1;
    p.push(temp);
    while (p.size())
    {
        temp = p.front();
        for (i = 0; i < 4; i++)
        {
            now.x = temp.x + dir[i][0];
            now.y = temp.y + dir[i][1];
            if (now.x >= 1 && now.x <= 5 && now.y >= 1 && now.y <= 5)
            {
                if (!leap[now.x][now.y] && a[now.x][now.y] == 0)
                {
                    dp[now.x][now.y] = dp[temp.x][temp.y] + 1;
                    p.push(now);
                    leap[now.x][now.y] = 1;
                }
            }
        }
        p.pop();
    }
    dfs(5,5);
    cout << "(4, 4)" << endl;
    return 0;
}