poj 3984 迷宫问题【bfs+路径记录】

迷宫问题

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 10103		Accepted: 6005

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

Sample Output

(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)

输出路径的方法为从终点倒退到起点 观察规律可知当前步的上一步必定是只能改变一个方向的值所以只有横坐标变或者只有纵坐标变所以可以确定下当前步上一步的位置（当步数相同时可以确定上一步的位置）自己想的代码  大神勿喷

#include<stdio.h>
#include<string.h>
#include<queue>
#define MAX 5000
using namespace std;
int map[5][5];
int n,m;
int bu[100][100];
int s[MAX];//记录位置的横坐标 
int s1[MAX];//记录位置的纵坐标 
struct node
{
    int x,y;
    int step;
    friend bool operator < (node a,node b)
    {
        return a.step>b.step;
    }
};
int bfs(int x1,int y1,int x2,int y2)
{
    int i,j,ok=0,k,t=1;
    int move[4][2]={0,1,0,-1,1,0,-1,0};
    priority_queue<node>q;
    node beg,end;
    beg.x=x1;
    beg.y=y1;
    q.push(beg);
    while(!q.empty())
    {
        end=q.top();
        q.pop();
        if(end.x==x2&&end.y==y2)
        {
            break;
        }
        for(i=0;i<4;i++)
        {
            beg.x=end.x+move[i][0];
            beg.y=end.y+move[i][1];
            if(0<=beg.x&&beg.x<5&&0<=beg.y&&beg.y<5&&map[beg.x][beg.y]==0)
            {
                map[beg.x][beg.y]=1;
                beg.step=end.step+1;
                bu[beg.x][beg.y]=beg.step;//记录对应步数时的节点位置 
                q.push(beg);
            }
        }
    }
    s[0]=4;s1[0]=4;//初值为终点，倒着打印出最短路径 
    for(i=end.step-1;i>=0;i--)
    {
        for(j=0;j<5;j++)
        {
            for(k=0;k<5;k++)
            {
                if(bu[j][k]==i)
                {
                    if((j==s[t-1]-1&&k==s1[t-1])||(k==s1[t-1]-1&&j==s[t-1]))//观察规律可知当前步的上一步必定是只能改变 
                    {                                                        //一个方向的值所以只有横坐标变或者只有纵坐标变 
                        s[t]=j;  //记录下路径 
                        s1[t]=k;
                        t++;
                    }
                }
            }
        }
    }
    printf("(0, 0)\n");
    for(i=t-1;i>=0;i--)
    {
        printf("(%d, %d)\n",s[i],s1[i]);
    }
}
int main()
{
    int i,j,k,sum;
    for(i=0;i<5;i++)
    for(j=0;j<5;j++)
    scanf("%d",&map[i][j]);
    memset(bu,0,sizeof(bu));
    bfs(0,0,4,4);
    return 0;
}

#include<stdio.h>
#include<string.h>
#include<queue>
#define MAX 210
using namespace std;
int map[6][6];
struct node
{
    int x,y;
    int time;
    friend bool operator < (node a,node b)
    {
        return a.time>b.time;
    }
};
int a[MAX],b[MAX];
void bfs(int x1,int y1,int x2,int y2)
{
    int i,j,ok=0,k=0;
    priority_queue<node>q;
    int move[4][2]={0,1,0,-1,1,0,-1,0};
    node beg,end;
    beg.x=x1;
    beg.y=y1;
    beg.time=0;
    q.push(beg);
    while(!q.empty())
    {
        end=q.top();
        q.pop();
        if(end.x==x2&&end.y==y2)
        {
             ok=1;
             break; 
        }
        for(i=0;i<4;i++)
        {
            beg.x=end.x+move[i][0];
            beg.y=end.y+move[i][1];
            if(beg.x>=0&&beg.x<5&&beg.y>=0&&beg.y<5&&map[beg.x][beg.y]!=1)
            {
                beg.time=end.time+1;
                a[k]=beg.x;
                b[k++]=beg.y;
                map[beg.x][beg.y]=1;
                q.push(beg);
            }
        }
    }
    if(ok)
    {
        printf("(0, 0)\n");
        int d=0,e=0;
        for(i=0;i<k;i++)
        {
            if(a[i]==d&&b[i]==e+1||a[i]==d+1&&b[i]==e)
            {
                d=a[i];
                e=b[i];
                printf("(%d, %d)\n",a[i],b[i]);
            }
        }
         
    }
}
int main()
{
    int i,j;
    int x1,y1,x2,y2;
    for(i=0;i<5;i++)
    {
        for(j=0;j<5;j++)
        {
            scanf("%d",&map[i][j]);
        }
    }
    bfs(0,0,4,4);
    return 0;
}