7084:迷宫问题

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)

题目分析
本题目和其他迷宫题目一样，都要求求到最短路径。但不同点在于这道题要输出的是路径过程而不是路径长度，因此我们在结构体中不能只定义点的坐标，还需要定义到达该点的上一步点的结构体数组下标(father)。本题目需要用到之前的队列数据，所以直接使用FIFO队列(queue)并不是特别方便，可以用数组（que）来代替队列，虽然浪费了空间，但是更加方便。
接下来在主函数（main）内，先定义一个数组（maze）表示迷宫，然后输入。再将数组que的第一个元素（起点）的坐标(x,y)赋值为(0,0)（左上角）。定义head和tail分别表示队首和队尾在que中的坐标。
while循环head < tail（队列不为空）。定义一个向量F，分别指向四个方向。将队尾元素的坐标改变，然后队尾元素的前一步下标应是head。判断坐标是否超界或是否为墙，再判断当前位置是否为终点，若是，就要输出答案，否则继续循环。
输出答案是本题的一大考点。我们为了节约空间，可以定义一个动态数组（vec），但是我们发现，只使用一个结构体并不够，我们还需要另一个结构体（WAY）表示路径的坐标。先将当前的点存入vec，然后我们可以定义一个元素（G）指向下标，初值为队尾元素的father。然后进行一个无限循环：1.将当前G指向的队列元素坐标存入vec；2.若当前点的位置是起点，则循环结束；3.G的值改变为当前G指向元素的father。由于我们是反向向起点倒推的，因此输出也应该反向输出。

程序样例

#include<cstdio>
#include<vector>
//动态数组头文件
using namespace std;
struct POINT
{
    int x,y,father;
}que[30];//队列
struct WAY
{
    int x,y;
}FIRST;
int F[4][2]={{1,0},{-1,0},{0,1},{0,-1}},head,tail=1; //向量，队首，队尾
bool maze[6][6]; //迷宫
int main()
{
    for(int i=0;i<5;i++) //输入
        for(int j=0;j<5;j++)
            scanf("%d",&maze[i][j]);
    que[0].x=0,que[0].y=0,que[0].father=-1; //起点，为了father不为空，赋值为-1
    while(head<tail) //队列不为空
    {
        for(int i=0;i<4;i++)
        {
            que[tail].father=head;
            que[tail].x=que[head].x+F[i][0]; //改变坐标
            que[tail].y=que[head].y+F[i][1];
            if(que[tail].x<0 || que[tail].x>=5 || que[tail].y<0 || que[tail].y>=5 || maze[que[tail].x][que[tail].y]) continue; //越界或为墙
            if(que[tail].x==4 && que[tail].y==4) //到达终点
            {
                vector<WAY> vec;
                FIRST.x=que[tail].x,FIRST.y=que[tail].y;
                vec.push_back(FIRST);
                int G=que[tail].father;
                while(1) //反推路径
                {
                    FIRST.x=que[G].x;FIRST.y=que[G].y;
                    vec.push_back(FIRST);
                    if(que[G].x==0 && que[G].y==0) break;
                    G=que[G].father;
                }
                int svec=vec.size();
                for(int i=svec-1;i>=0;i--) //反向输出
                    printf("(%d, %d)\n",vec[i].x,vec[i].y);
                return 0;
            }
            tail++;
        }
        head++;
    }
    return 0;
}