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 <cstdio>
#include <cstring>
#include <cstdlib>


using namespace std;
int maze[5][5];
int w[4][2] ={1,0,-1,0,0,-1,0,1};
int front = 0,rear = 0;
struct node
{
    int x;
    int y;
    int pre;//前驱
}p[100];
void print (int i)
{
   if(p[i].pre !=-1)
   {
       print (p[i].pre);
       cout << "("<< p[i].x<< ", "<< p[i].y << ")"<< endl;
   }
   else
   {
       cout << "(0, 0)"<< endl;
   }
}
void bfs(int x1, int y1)
{
    p[front].x = x1;
    p[front].y = y1;
    p[front].pre = -1;
    rear++;//入队
    while (front < rear)//不为空
    {
        //把队列的头结点的周围点入队
        for(int i = 0; i < 4; i++)
        {
            int a = w[i][0]+p[front].x;
            int b = w[i][1]+p[front].y;
            if(a <0 || a >= 5 || b < 0 || b >= 5 || maze[a][b])
            {
                continue;
            }
            else
            {
                maze[a][b] = 1;
                p[rear].x = a;
                p[rear].y = b;
                p[rear].pre = front;
                rear++;
            }
            if(a == 4 && b== 4)
            {
                print(front);
                cout<< "(4, 4)"<< endl;
                return ;
            }


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

代码：dfs

   
   

    
    

     
     
#include <cstring>
#include <cstdlib>
#include <queue>
#include <stack>
#include <vector>

using namespace std;
int maze[5][5];
int visit[5][5];

struct node
{
    int x;
    int y;
};
vector<node> q;
stack<node>p;

void dfs (int x1, int y1)
{
    if(!visit[x1][y1])//未被访问过
    {
        node s;
        s.x = x1;
        s.y = y1;
        p.push(s);//放到栈
        visit[x1][y1] = 1;
    }
    if(x1 == 4 && y1 == 4)
    {
        return ;
    }

    if(!visit[x1+1][y1] && !maze[x1+1][y1]) //向下一定是第一次访问
    {
        dfs(x1+1,y1);
    }
    else if (!visit[x1][y1+1] && !maze[x1][y1+1])//向右一定是第一次访问
    {
        dfs(x1,y1+1);
    }
    else//向上和左一定是回溯，即倒回上一步，要先pop当前一步，回到上一步
    {
        p.pop();
        node d ;
        d = p.top();
        dfs(d.x,d.y);
    }
}
int main()
{
    for (int i = 0; i < 5;i++)
    {
        for (int j = 0; j < 5; j++)
        {
            scanf("%d",&maze[i][j]);
        }
    }
    memset(visit,0,sizeof(visit));
    dfs(0,0);
    while (!p.empty())//把栈元素放到vector中
    {
        q.push_back(p.top());
        p.pop();
    }
    for (int i = q.size()-1; i >= 0; i--)//逆序输出
    {
        cout << "("<< q[i].x << ", "<< q[i].y << ")" << endl;
    }

    return 0;
}