poj3984迷宫问题解题报告

来自本人百度博客 2011-10-28 14:52

问题描述：

迷宫问题

Time Limit: 1000MS

 

Memory Limit: 65536K

Total Submissions: 3577

 

Accepted: 2093

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)

 

算法与数据结构：

本题不需要特别的数据结构，按照本来的棋盘存储即可。

算法非常简单，最标准的款搜。这里简单讲一下BFS：

BFS全称是Breadth First Search，顾名思义按照宽度优先搜索。宽度是跟深度相对的，决策的次数就是深度，而同一次决策的各种情况则为宽度（这只是一种形象的说法，标准定义大家去问《导论》吧~）。为了实现BFS，我们需要构造一个队列，将新的决策不断加入对位，每次需要搜索下一个决策时，弹出队头。为什么这样的结构能够搜索到最优解，大家可以自己研究研究~~^_^。对于本题，我们可以预先做些事情，比如处理好四个方向坐标的改变量，下面代码中大家就会看到。当然，如果直接强行的搜，大概可以到4^25这个数量级。我们可以看一下题目，注意到，在队列中，一个格子只能够出现一次，如果某格子在队中第二次出现的话，可以证明，着一定不是最优解。在搜索时，只要格子入队，就把它的值变为“1”。

Course code：

 

#include<iostream>

using namespace std;

 

int di[4][2]={{-1,0},{0,1},{1,0},{0,-1}}; //四个方向上的值

int maze[7][7],dui[1000000][3],h,t;//maze是迷宫，dui是队列，完全不用开那么大，dui[][0]

             //是x坐标，dui[][1]是y坐标，dui[][2]存储父节点，h是

             //头指针，t是尾指针

 

int print(int a)

{//这是最后输出的函数，用一种递归的方法非常方便。

        if (dui[a][2]>0)

        print(dui[a][2]);//利用dui[][2]打印前面的坐标

 

        cout<<"("<<dui[a][0]<<", "<<dui[a][1]<<")"<<endl;//打印本点的坐标

    return 0;

}

 

int main()

{

    int i,j,k;

 

       for (i=0;i<5;i++)//读入迷宫

              for (j=0;j<5;j++)   cin>>maze[i][j];

 

       h=0;       t=1;//初始化队列

       dui[1][0]=0;

       dui[1][1]=0;

       dui[1][2]=0;

       maze[0][0]=1;

 

    while (h!=t)//bfs

{

        h++;//弹出对头

        if (dui[h][0]==4&&dui[h][1]==4)//循环结束

        {

            print(dui[t][2])；

            cout<<"("<<dui[t][0]<<", "<<dui[t][1]<<")";//因为poj猥琐的格式，最后一

                                                             //行单独打印，后面没有换行

            break;

        }

 

              for (i=1;i<=4;i++)//搜索四个方向进行决策

              {

                     int tmpx=dui[h][0]+di[i][0];

                     int tmpy=dui[h][1]+di[i][1];                     

 

                     if (tmpx>=0&&tmpx<=4&&tmpy>=0&&tmpy<=4&&maze[tmpx][tmpy]==0)

                     {//入队操作

                            t++;

                            dui[t][0]=tmpx;

                            dui[t][1]=tmpy;

                            dui[t][2]=h;

                            maze[tmpx][tmpy]=1;

                     }

              }

       }

 

    return 0;

}