《简单迷宫问题》（dfs）

定义一个二维数组：
int maze[5][5] = {
0, 1, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
};
它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的路线。

• [ ]

> 输入 	一个5 × 5的二维数组，表示一个迷宫。数据保证只有一条唯一的路径。 	输出
>        	左上角到右下角的路径（走过的路不能再重复走），格式如样例所示。 	样例输入 	0 1 0 0 0 0 1 1 1 0 0 0 0
>        0 0 0

1 1 1 0
0 0 0 1 0

样例输出
(0, 0)

(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)
看到网上大部分都是用bfs做的，所以写了下。
这个问题其实dfs一下就行了，主要就是在于这个输出的顺序，这里我们用栈来储存输出的位置，就能实现要达到的顺序。

**

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
//#define INF 0x3f3f3f3f
struct Node
{
    int x,y;
}p;
int b[4][2] = {1,0,-1,0,0,1,0,-1},vis[5][5],v[5][5],flag;
stack<Node> S;
void dfs(int x,int y)
{
    int px,py,i;
    if(x == 4 && y == 4)
    {
        p.x = x;
        p.y = y;
        S.push(p);
        flag = 1;
        return ;
    }
    for(i=0;i<4;++i)
    {
        px = x+b[i][0];
        py = y+b[i][1];
        if(vis[px][py] != 1 && px >= 0 && px < 5 && py >= 0 && py < 5 && v[px][py] == '0')
        {
            vis[px][py] = 1;
            dfs(px,py);
            if(flag == 1)
            {
                p.x = x;
                p.y = y;
                S.push(p);
                return ;
            }
        }
    }
}
int main()
{
    char s[10];
    int i;
    memset(vis,0,sizeof(vis));
    flag = 0;
    for(i=0;i<5;++i)
    {
        gets(s);
        v[i][0] = s[0];
        v[i][1] = s[2];
        v[i][2] = s[4];
        v[i][3] = s[6];
        v[i][4] = s[8];
    }
    vis[0][0] = 1;
    dfs(0,0);
    while(!S.empty())
    {
        p = S.top();
        S.pop();
        printf("(%d, %d)\n",p.x,p.y);
    }
}*/**