POJ 2251 Dungeon Master BFS（广度优先搜索）

题目链接点这里
题目内容：
**Dungeon Master
Time Limit: 1000MS Memory Limit: 65536K
Total Submissions: 29640 Accepted: 11529
Description

You are trapped in a 3D dungeon and need to find the quickest way out! The dungeon is composed of unit cubes which may or may not be filled with rock. It takes one minute to move one unit north, south, east, west, up or down. You cannot move diagonally and the maze is surrounded by solid rock on all sides.

Is an escape possible? If yes, how long will it take?
Input

The input consists of a number of dungeons. Each dungeon description starts with a line containing three integers L, R and C (all limited to 30 in size).
L is the number of levels making up the dungeon.
R and C are the number of rows and columns making up the plan of each level.
Then there will follow L blocks of R lines each containing C characters. Each character describes one cell of the dungeon. A cell full of rock is indicated by a ‘#’ and empty cells are represented by a ‘.’. Your starting position is indicated by ‘S’ and the exit by the letter ‘E’. There’s a single blank line after each level. Input is terminated by three zeroes for L, R and C.
Output

Each maze generates one line of output. If it is possible to reach the exit, print a line of the form
Escaped in x minute(s).

where x is replaced by the shortest time it takes to escape.
If it is not possible to escape, print the line
Trapped!
Sample Input

3 4 5
S….
.###.
.##..
###.#

#####
#####
##.##
##…

#####
#####
#.###
####E

1 3 3
S##
#E#
###

0 0 0
Sample Output

Escaped in 11 minute(s).
Trapped!**

题意分析：走迷宫问题，不同的就是走的是3D迷宫，比起二维的迷宫也就多了上，下两个方向而已。以前上黄某毒老师的课时老师说，走迷宫问题宜用BFS广搜，然后如何如何，但很水的我并没有认真听课，所以做这道题前先试着写了一个走二维迷宫的demo,然后稍作改动直接submit,毫无意外的WA，找了大半个小时的错误，问题是：以前的好几个变量都设置的是全局变量，一轮测试数据过后，到第二轮数据就会出错。。。发现问题后就很快AC了

顺便，做这道题的时候体会到了STL的便捷。。。

附AC代码：

#include<iostream>
#include<queue>
#include<string.h>
#include<stdio.h>

using namespace std;

char a[31][31][31];
bool vis[31][31][31];
int L,R,C;
int dirx[6]={1,-1,0,0,0,0};
int diry[6]={0,0,1,-1,0,0};
int dirz[6]={0,0,0,0,1,-1};

struct node{
    int z;
    int x;
    int y;
    int path;
};
void bfs(node &q)
{
    node u,v;
    queue<node> Q;
    Q.push(q);
    while(!Q.empty())
    {
        u=Q.front();
        Q.pop();
        for(int i=0;i<6;i++)
        {
            v.x=u.x+dirx[i];
            v.y=u.y+diry[i];
            v.z=u.z+dirz[i];
            v.path=u.path;
            if(v.x<0||v.x>=R||v.z<0||v.z>=L||v.y<0||v.y>=C)
                continue;
            if((a[v.z][v.x][v.y]=='.'||a[v.z][v.x][v.y]=='E')&&!vis[v.z][v.x][v.y])
            {
                vis[v.z][v.x][v.y] = true;
                v.path++;
                Q.push(v);
                if(a[v.z][v.x][v.y]=='E'){
                    cout<<"Escaped in "<<v.path<<" minute(s)."<<endl;return;
                }
            }
        }
    }
    cout<<"Trapped!"<<endl;
}
int main()
{
    while(cin>>L>>R>>C&&(L!=0||R!=0||C!=0))
    {
        node q;
        for(int i=0;i<L;i++)
        {    for(int j=0;j<R;j++)
             {
                 cin>>a[i][j];
                 for(int k=0;k<C;k++)
                 {
                    if(a[i][j][k]=='S')
                    {
                        q.z=i;q.x=j;q.y=k;
                        q.path=0;
                    }
                 }
             }
        }
        memset(vis,false,sizeof(vis));
        vis[q.z][q.x][q.y] = true;
        bfs(q);
    }
    return 0;
}

不如再附上走二维迷宫的demo：

#include<iostream>
#include<queue>
#include<string.h>

using namespace std;

int R,C;
char a[10][10];
bool vis[10][10];
int dirx[4]={1,-1,0,0};
int diry[4]={0,0,1,-1};

struct node{
    int x;
    int y;
    int path;
};

void bfs(node &q)
{
    node u,v;
    queue<node> Q;
    Q.push(q);
    while(!Q.empty())
    {
        u=Q.front();
        Q.pop();
        for(int i=0;i<4;i++)
        {
            v.x=u.x+dirx[i];
            v.y=u.y+diry[i];
            v.path=u.path;
            if(v.x<0||v.x>=R||v.y<0||v.y>=C)
                continue;
            if((a[v.x][v.y]=='.'||a[v.x][v.y]=='E')&&!vis[v.x][v.y])
            {
                vis[v.x][v.y] = true;
                v.path++;
                Q.push(v);
                if(a[v.x][v.y]=='E'){
                    cout<<"共需 "<<v.path<<" 步方可走出"<<endl;return;
                }
            }
        }
    }
    cout<<"走不出去了"<<endl;
}
int main()
{
    while(cin>>R>>C&&(R!=0&&C!=0))
    {
        node q;
        for(int i=0;i<R;i++)
        {
            cin>>a[i];
            for(int j=0;j<C;j++)
            {
                if(a[i][j]=='S')
                {
                    q.x=i;q.y=j;
                    q.path=0;
                }
            }
        }
        memset(vis,false,sizeof(vis));
        vis[q.x][q.y] = true;
        bfs(q);
    }
    return 0;
}