POJ 3984 迷宫问题

先上题

定义一个二维数组：

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)

搜索问题，因为前两篇博客都写的是深搜，就用深搜写了。
先说最开始的思路：深搜压栈。就是在模拟上下左右的时候先向右或者先向下走，这样就可以找到最短路。就是在标记后，递归前将坐标压入栈中，回溯后将该坐标删除，这样在到达终点的时候就是一条通往终点的路线。但此次并没有AC，有一个错误的点，先上代码。

#include <iostream>
#include <bits/stdc++.h>
#include <stack>
#include <algorithm>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <string.h>
using namespace std;
int a[10][10];//打印地图
int b[10][10]={0};//标记数组
int x,y;
int dx[4]={0,1,0,-1};//模拟上下左右
int dy[4]={1,0,-1,0};
stack<int>s1;
stack<int>s2;
stack<int>s3;
stack<int>s4;
void dfs(int x,int y)
{
    if(x==4&&y==4)
    {
        while(!s1.empty()&&!s2.empty())
        {

            s3.push(s1.top());
            s4.push(s2.top());
            s1.pop();
            s2.pop();
        }
        while(!s3.empty()&&!s4.empty())
        {
            cout<<"("<<s3.top()<<","<<' '<<s4.top()<<")"<<endl;
            s3.pop();
            s4.pop();
        }
        return;
    }
    if(x>4||y>4)
        return;
    for(int i=0;i<4;i++)//通过i的值来控制下一步上下左右移动
    {
        int tx,ty;
        tx=x+dx[i];
        ty=y+dy[i];
        if(tx>=0&&tx<=4&&ty>=0&&ty<=4)
        {
            if(a[tx][ty]==0&&b[tx][ty]==0)
            {
                b[tx][ty]=1;
                s1.push(tx);
                s2.push(ty);
                dfs(tx,ty);//递归
                s1.pop();
                s2.pop();
                b[tx][ty]=0;//回溯
            }
        }
    }
}

int main()
{

    for(int i=0;i<5;i++)
    {
        for(int j=0;j<5;j++)
        {
            cin>>a[i][j];

        }
    }
    s1.push(0);
    s2.push(0);
    dfs(0,0);

    return 0;
}

因为深搜遍历所有线路，所以可能找到一条最短路，但问题在于当它还没有遍历整个迷宫的时候，他不知道这条路是不是最短的，所以不能找到就输出，即使是先右或者先下，还是不能确保找到的就是最短路。这个代码可以过所给出的样例。但如果是
0 0 0 0 1
0 1 1 0 1
0 1 0 0 1
0 1 0 1 0
0 0 0 0 0
就会输出向右走的那条路，很显然不是最短路。
然后换了个思路，还是dfs但是不用栈了加上了步数，即要找到最短的路，然后找到一条路的同时比较步数，然后将标记数组存起来，这就是最短路的图，最后在输出时要注意按照搜索时模拟的上下左右顺序输出。AC代码：

#include <iostream>
#include <bits/stdc++.h>
#include <stack>
#include <algorithm>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <string.h>
using namespace std;
int a[10][10];//打印地图
int b[10][10]={0};//标记数组
int x,y,step,temp=10000;
int dx[4]={0,1,0,-1};//模拟上下左右
int dy[4]={1,0,-1,0};
int flag[10][10];
void dfs(int x,int y,int step)
{
    if(x==4&&y==4)
    {
        if(step<temp)
        {
            temp=step;
            for(int i=0;i<5;i++)
            {
                for(int j=0;j<5;j++)
                    flag[i][j]=b[i][j];
            }
        }
        return;
    }
    if(x>4||y>4)
        return;
    for(int i=0;i<4;i++)//通过i的值来控制下一步上下左右移动
    {
        int tx,ty;
        tx=x+dx[i];
        ty=y+dy[i];
        if(tx>=0&&tx<=4&&ty>=0&&ty<=4)
        {
            if(a[tx][ty]==0&&b[tx][ty]==0)
            {
                b[tx][ty]=1;
                dfs(tx,ty,step+1);//递归
                b[tx][ty]=0;//回溯
            }
        }
    }
}
void road()
{
    int tx=0,ty=0,x=0,y=0;
    cout<<"("<<0<<", "<<0<<")"<<endl;
    for(int s=0;s<temp;s++)
    {
        for(int i=0;i<4;i++)
    {
       tx=x+dx[i],ty=y+dy[i];
       if(tx>=0&&tx<5&&ty>=0&&ty<5&&flag[tx][ty]==1)
        {
            cout<<"("<<tx<<", "<<ty<<")"<<endl;
            x=tx,y=ty;
            break;
        }
    }
    }
    return ;
}
int main()
{

    for(int i=0;i<5;i++)
    {
        for(int j=0;j<5;j++)
        {
            cin>>a[i][j];

        }
    }
    dfs(0,0,0);
    road();
    return 0;
}

学习的路还很长。