Poj3984--迷宫问题（BFS）

迷宫问题
Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 131072/65536K (Java/Other)
Total Submission(s) : 10056   Accepted Submission(s) : 5652
Problem 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)
 
 

Source
PKU

路径输出， 递归输出较为简洁。

ac代码：

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;

const int MAX = 10;
struct point
{
    int x,y,pre;    
}q[MAX];
int front = 0, rear = 1, sx, sy, ex, ey;
int arr[MAX][MAX];
int dx[4]={1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int n, m;
void output(int i)              
{
    if(q[i].pre != -1)
    {
        output(q[i].pre);
        printf("(%d, %d)
",q[i].x,q[i].y);
    }
}

void bfs(int sx,int sy)
{
    q[front].x = sx;
    q[front].y = sy;
    q[front].pre = -1;
    arr[sx][sy] = 1;
    while(front < rear)     //模拟； 
    {
        for(int i=0;i<4;i++)
        {
            int nx = q[front].x + dx[i];
            int ny = q[front].y + dy[i];
            if(nx<0 || nx>=5 || ny<0 || ny>=5 || arr[nx][ny])
                continue;
            else
            {
                arr[nx][ny] = 1;
                q[rear].x = nx;
                q[rear].y = ny;
              // printf("%d %d
", q[rear].x, q[rear].y); 
                q[rear++].pre = front;
            }                                                                          
            if(nx == 4 && ny == 4)  output(front);
        }
        front++;
    }
}

int main()
{
    for(int i=0;i<5;i++)
        for(int j=0;j<5;j++)
                scanf("%d",&arr[i][j]);
    printf("(0, 0)
");
    bfs(0,0);
    printf("(4, 4)
");
    return 0;
} 

/*输出迷宫路径， 要记录前驱，输出时是从开始到结尾，所以要处理一下。*/  
#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
const int INF = 0x3f3f3f3f;
int minn = INF;
int map[10][10], Ax[10], Ay[10], ac[4][2] = {0, 1, 0, -1, -1, 0, 1, 0};
struct Rode
{
    int x, y, step;
} a, temp, ans, pre[20][20];

bool Judge(Rode &temp)
{
    if(temp.x >= 0 && temp.y >= 0 && temp.x < 5 && temp.y < 5 && map[temp.x][temp.y] == 0)
        return true;
    else
        return false;
}
void Bfs()
{
    queue<Rode> q; 
    a.x = 0; a.y = 0; a.step = 0;
    q.push(a); 
    map[0][0] = 1;
    while(!q.empty())
    {
        a = q.front();
        q.pop(); 
        temp = a;
        for(int i = 0; i < 4; i++)
        {
            temp.x = a.x + ac[i][0];
            temp.y = a.y + ac[i][1];
            temp.step = a.step + 1;    
            if(Judge(temp))
            {
                if(temp.x == 4 && temp.y == 4)
                {
                    if(temp.step < minn)
                    {
                        minn = temp.step; 
                        pre[4][4].x = a.x;
                        pre[4][4].y = a.y;
                    }
                    continue;
                } 
                map[temp.x][temp.y] = 1;
                pre[temp.x][temp.y].x = a.x;
                pre[temp.x][temp.y].y = a.y;
                q.push(temp);
            }
        } 
    } 
} 
int main()
{
    for(int i = 0; i < 5; i++)
        for(int j = 0; j < 5; j++)
            scanf("%d", &map[i][j]);
    Bfs();
    int x, y, k = 0;
    x = y = 4;
    while(1)  
    {  
        int tx,ty;  
        tx=x;  
        ty=y;  
        if(!pre[x][y].x&&!pre[x][y].y)  
            break;  
        Ax[k]=pre[tx][ty].x; 
        Ay[k++] = pre[tx][ty].y; 
        x=pre[tx][ty].x;  
        y=pre[tx][ty].y;  
    }  

    printf("(0, 0)
");  
    for(int i = k - 1; i >= 0; i--)
        printf("(%d, %d)
", Ax[i], Ay[i]);
    printf("(4, 4)
");
    return 0;
}