poj3984-迷宫问题(广搜)

迷宫问题
Time Limit: 1000MS Memory Limit: 65536K
Total Submissions: 10736 Accepted: 6400
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)

//memory:224k time:0ms
#include<iostream>
#include<cstdio>
#include<queue>
#include<stack>
const int size = 5;
using namespace std;
int **maze;     //二维数组
struct point{
    int x,
        y;
};
point **pre;    //二维结构体
int row = size;
int col = size;
point move[4] = {{1,0},{0,1},{-1,0},{0,-1}};    //四个移动方向
void createmaze(int row, int col)   //用1把maze的四周包围起来，免去判断是否出界的麻烦
{
    for(int i = 0; i < col + 2; i ++)
    {
        maze[0][i] = maze[row + 1][i] = 1;
    }
    for(int j = 0; j < row + 2; j ++)
    {
        maze[j][0] = maze[j][col + 1] = 1;
    }
    for(int i = 1; i < row + 1; i ++)
        for(int j = 1; j < col + 1; j ++)
            cin >> maze[i][j];
}

void findpath(int row, int col, int x, int y)
{
    if(x == row && y == col)//找到终点
        return ;
    queue<point> q;         //队列用于记录储存点
    point now;
    now.x = x;
    now.y = y;
    q.push(now);            //当前点压栈
    maze[now.x][now.y] = -1;
    while(!q.empty())       //找不到出口q就为空了
    {
        now = q.front();    //读取队首点
        q.pop();            //队首点出列
        for(int i = 0; i < 4; i ++)
        {
            if(now.x + move[i].x == row && now.y + move[i].y == col)    //判断是否到达终点
            {
                pre[row][col] = now;    //记录路径
                maze[now.x + move[i].x][now.y+move[i].y] = -1;    //标记，不能再走
                return;
            }
            else if(maze[now.x + move[i].x][now.y+move[i].y] == 0 )    //判断是否有出口
            {
                point temp;    //临时点 记录下一个点的位置
                temp.x = now.x + move[i].x;
                temp.y = now.y + move[i].y;
                q.push(temp);    //把下一个点压栈 在循环开始处会成为当前点，这就是队列的作用，FIFO
                maze[temp.x][temp.y] = -1;
                pre[temp.x][temp.y] = now;
            }
        }
    }
}
void printpath()
{
    stack<point> q;    //定义栈，用于从终点开始存储路径
    point temp ;    //从终点开始
    temp.x = row;
    temp.y = col;
    while(temp.x != 1 || temp.y != 1)    //是否到达起点
        {
            q.push(temp);    
            temp = pre[temp.x][temp.y];    //temp不断前移
        }
    q.push(temp);    //最后一个点也要压入
    while(!q.empty())    //输出
    {
        temp = q.top();    //从栈顶开始输出，利用栈的特性从起点开始输出
        cout << "(" << temp.x - 1<< ", " << temp.y - 1 << ")" << endl;    //因为输入的时候从1开始，这里要减1.
        q.pop();    //用一个点出一个
    }
}
int main()
{
   //freopen("output.txt","r",stdin);
    maze = new int*[row + 2];
    pre = new point*[row + 2];
    for(int i = 0; i < row + 2; i ++)
    {
        maze[i] = new int[col + 2];
        pre[i] = new point[col + 2];
    }
    createmaze(row, col);

    findpath(row,col,1,1);
//    for(int i =1; i < row + 1; i ++)
//    {
//        for(int j = 1; j < col + 1; j ++)
//            cout << pre[i][j].x << "." << pre[i][j].y <<" ";
//        cout << endl;
//    }
    printpath();
    return 0;
}