【POJ】3984迷宫问题（BFS）

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 35895		Accepted: 20323

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)

思路：其实还是可以的一个BFS，可以看一下我代码上的那个路径保存输出的方式，路径长度有点多余，本来想着靠这个判断什么时候路径输出截止来着，貌似用不到了。。。

#include<iostream>
#include<cstring>
#include<string>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<stack>
using namespace std;

int maze[6][6];
int vis[6][6],dist[6][6];
int dr[]={-1,0,1,0};
int dc[]={0,1,0,-1};

struct Node
{
    int r,c;
    Node(int r,int c):r(r),c(c){}
    Node(){}
}pre[6][6];

queue<Node> Q;
void BFS()
{
    while(!Q.empty()) Q.pop();
    memset(vis,0,sizeof(vis));
    dist[0][0]=0;
    vis[0][0]=1;
    Q.push(Node(0,0));

    while(!Q.empty())
    {
        Node node=Q.front();Q.pop();
        int r=node.r,c=node.c;

        for(int d=0;d<4;d++)
        {
            int nr=r+dr[d];
            int nc=c+dc[d];

            if(nr>=0&&nr<5 && nc>=0&&nr<5 &&vis[nr][nc]==0 &&maze[nr][nc]==0)
            {
                vis[nr][nc]=1;
                Q.push(Node(nr,nc));
                dist[nr][nc]=dist[r][c]+1;
                pre[nr][nc]=Node(r,c);

                if(nr==4&&nc==4)
                    return;
            }
        }
    }
}

int main()
{
    for(int i=0;i<5;i++)
        for(int j=0;j<5;j++)
            cin>>maze[i][j];
    BFS();
    stack<Node> S;

    int cur_r=4,cur_c=4;
    while(true)
    {
        S.push(Node(cur_r,cur_c));
        if(cur_r==0&&cur_c==0) break;
        int r=cur_r,c=cur_c;
        cur_r=pre[r][c].r;
        cur_c=pre[r][c].c;
    }
    while(!S.empty())
    {
        Node node=S.top(); S.pop();
        printf("(%d, %d)\n",node.r,node.c);
    }
    return 0;
}

【POJ】3984迷宫问题（BFS）

猜你喜欢