POJ 2251 Dungeon Master（dfs）

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!

就是一个人被逮到地牢里面了，地牢有好几层（L），每层R*C，标#的地方不能走，每次可以上、下、左、右、前、后走一个相邻的格子，花费1分钟。问你从S走，能不能逃出这个地牢（走到E）。
这是我认真的写的第一个dfs，是不是有点晚呢？呵呵。总结一下dfs的几个要点吧。

1.struct node 用于标记点的坐标，和到达（如果能）该店的步数。
2.vis dir 数组，分别表示  是否访问过  每次走的方向
3.check函数 ：检查3点 1->是否超出边界 2->是否走过 3->是否能走
4.基于队列实现的bfs函数，这里详细解释
首先我们建立一个node的队列q，我们先把起点加进队列。从当q的队首开始，用temp取得这个队首，q.pop().将通过temp能走到的node再加入到队列里面，同时判断是否到达终点。
这样知道q这个队列空了，我们就走完了所有可能的路了。

代码如下：

 #include <cstdio>
 #include <iostream>
 #include <cmath>
 #include <queue>
 #include <cstring>
 using namespace std;
 struct node
 {
     int l,x,y;
     int step;
 };
 int L,R,C;
 int el,ex,ey,sl,sx,sy,ans;
 char mp[][][];
 bool vis[][][];
 int dir[][]={,,, -,,, ,,, ,-,, ,,, ,,-};
 bool check(node now)
 {
     if (now.l>=L||now.l<||
         now.x>=R||now.x<||
         now.y>C||now.y<)
     return ;
     if (mp[now.l][now.x][now.y]=='#'||vis[now.l][now.x][now.y])
     return ;
     return ;
 }
 void bfs (int level,int xx,int yy)
 {
     queue<node> q;
     node now;
     now.l=level,now.x=xx,now.y=yy,now.step=;
     vis[level][xx][yy]=true;
     q.push(now);
     while (!q.empty())
     {
         node temp=q.front();
         q.pop();
         for (int i=;i<;++i)
         {
             now.l=temp.l+dir[i][];
             now.x=temp.x+dir[i][];
             now.y=temp.y+dir[i][];
             now.step=temp.step+;
             if (check(now))
             {
                 if (mp[now.l][now.x][now.y]=='E')
                 {
                     ans=now.step;
                     return;
                 }
                 vis[now.l][now.x][now.y]=true;
                 q.push(now);
             }
         }
     }
 }
 int main()
 {
     //freopen("de.txt","r",stdin);
     while (~scanf("%d%d%d",&L,&R,&C))
     {
         if (L==&&R==&&C==)
         break;
         el=ex=ey=;
         sl=sx=sy=;
         memset(vis,false,sizeof vis);
         for (int i=;i<L;++i)
         {
             for (int j=;j<R;++j)
             {
                 for (int k=;k<C;++k)
                 {
                     cin>>mp[i][j][k];
                     if (mp[i][j][k]=='S')
                     {
                         sl=i,sx=j,sy=k;
                     }
                     if (mp[i][j][k]=='E')
                     {
                         el=i,ex=j,ey=k;
                     }
                 }
             }
         }
         ans=-;
         bfs(sl,sx,sy);
         if (ans!=-)
         printf("Escaped in %d minute(s).\n",ans);
         else
         printf("Trapped!\n");
     }
     return ;
 }