POJ-3984-迷宫问题

原题链接：http://poj.org/problem?id=3984

迷宫问题

Time Limit: 1000MS    Memory Limit: 65536K
Total Submissions: 12515   Accepted: 7503



问题描述：

定义一个二维数组：

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)

解题思路：
这道题目可以从深搜和广搜两个方面考虑。题目给出的数组不是很大，所以进行广搜的时候所需的内存空间的大小可以满足题目的要求。广搜的最大好处就是可以短时间内获取最优解。深思之后，决定用广搜来解决这道题。
具体思路是先开一个队列一个栈，队列存储未扩展的结点，并将新的扩展结点放入队尾。将用过的结点放到栈中。当前扩展出的结点是迷宫出口，就直接放入栈中。再将这些栈中的点根据父节点找出最短的那条路径。

代码分析：

#include<iostream>
#include<queue>
#include<stack>
#include<algorithm>
using namespace std;
struct nod{
    int px, py;
    nod(){}
    nod(int x, int y) :px(x), py(y){}
};      
struct NodeL
{
    int fatherX, fatherY, X, Y;
    NodeL(){}
    NodeL(int fx, int fy, int x, int y) :fatherX(fx), fatherY(fy), X(x), Y(y){}
};
int visited[6][6];  //标记此结点是否已经走过
int  S[6][6], fx, fy;  //s存放迷宫，fx,fy记录父节点的行列值
queue<NodeL>Open;     //未扩展的结点
stack<NodeL>Closed;   //已经扩展过的结点
stack<nod>array;      //存放最短的那条路径行列值
void Bfs(NodeL Start)
{
    Open.push(Start);  //初始化队列
    while (!Open.empty())  //队列不为空，继续扩展
    {
        NodeL m = Open.front();  //取队头元素扩展
        Open.pop();              //队头弹出
        Closed.push(m);         //用过的结点放到Closed
        if (m.X + 1 > 0 && S[m.X + 1][m.Y] == 0 && visited[m.X + 1][m.Y] == 0) 
            //当前节点的下一行同列的值如果没被访问，并可以继续往前走
        {
            Open.push(NodeL(m.X, m.Y, m.X + 1, m.Y));
            //下行同列元素入队，并记住父结点
            if (m.X + 1 == 4 && m.Y == 4)
            { //如果当前结点已是迷宫出口，直接将当前结点放入Closed
                Closed.push(NodeL(m.X, m.Y, m.X + 1, m.Y));
                break;
            }
            else{
                //如果不是迷宫出口，入队
                Open.push(NodeL(m.X, m.Y, m.X + 1, m.Y));
            }
            visited[m.X + 1][m.Y] = 1;//将此结点标记为走过

        }
        //下面分别是向其他三个方向走，思路是相同的
        if (m.X - 1 > 0 && S[m.X - 1][m.Y] == 0 && visited[m.X - 1][m.Y] == 0)
        {  
            Open.push(NodeL(m.X, m.Y, m.X - 1, m.Y));
            if (m.X - 1 == 4 && m.Y == 4)
            {
                Closed.push(NodeL(m.X, m.Y, m.X - 1, m.Y));
                break;
            }
            else{
                Open.push(NodeL(m.X, m.Y, m.X - 1, m.Y));
            }
            visited[m.X - 1][m.Y] = 1;
        }
        if (m.Y - 1 > 0 && S[m.X][m.Y - 1] == 0 && visited[m.X][m.Y - 1] == 0)
        {
            Open.push(NodeL(m.X, m.Y, m.X, m.Y - 1));
            if (m.X - 1 == 4 && m.Y - 1 == 4)
            {
                Closed.push(NodeL(m.X, m.Y, m.X, m.Y - 1));
                break;
            }
            else{
                Open.push(NodeL(m.X, m.Y, m.X, m.Y - 1));
            }
            visited[m.X][m.Y - 1] = 1;
        }
        if (m.Y + 1 > 0 && S[m.X][m.Y + 1] == 0 && visited[m.X][m.Y + 1] == 0)
        {
            Open.push(NodeL(m.X, m.Y, m.X, m.Y + 1));
            if (m.X == 4 && m.Y + 1 == 4)
            {
                Closed.push(NodeL(m.X, m.Y, m.X, m.Y + 1));
                break;
            }
            else{
                Open.push(NodeL(m.X, m.Y, m.X, m.Y + 1));
            }
            visited[m.X][m.Y + 1] = 1;
        }
    }
}
int main()
{
    memset(S, 0, sizeof(S));
    for (int i = 0; i < 5; i++)
    for (int j = 0; j < 5; j++)
    {
        cin >> S[i][j];  //输入迷宫
    }
    Bfs(NodeL(-1, -1, 0, 0));  //从（0，0）点开始广度优先搜索
    array.push(nod(Closed.top().X, Closed.top().Y));
    //将放有用过结点的closed中的最后一点,有就是迷宫出口放入Array
    fx = Closed.top().fatherX; //取出口点的父结点
    fy = Closed.top().fatherY;
    Closed.pop();  
    while (!Closed.empty())//继续找与父节点相同值的行列值
    {
        if (Closed.top().X == fx&&Closed.top().Y == fy)
        {
            array.push(nod(Closed.top().X, Closed.top().Y));
            fx = Closed.top().fatherX;
            fy = Closed.top().fatherY;
            Closed.pop();
        }
        else Closed.pop();
    }
    while (!array.empty())
    {
        cout << "(" << array.top().px << ", " << array.top().py << ")" << endl;
        //输出栈中存储的最短路径
        array.pop();
    }
    return 0;
}