Dungeon Master （BFS与DFS的应用）

个人心得：一开始用DFS弄了半天一直输出不了结果，后面发现并没有进行判断；好不容易能够得出答案，结果超时了，才发现原来要用BFS；

对于DFS：

从一个点开始模拟能走的所有步骤，注意边界条件，走到不能走时返回上一步继续循环；耗时比较大，主要要注意当前的动作

格式的话

void dfs（int step）

{

判断边界

尝试每一种可能

{

注意标记；

继续下一步；

}

返回

}

BFS广度搜索，能够走得位置都走，将能到达的位置进入队列，当一个位置的所有动作完成时出队列，注意标志不改变，当队列为空时搜索完毕，当然找最小步伐时第一次到达时便是最小步骤！

struct Node

{

int x;//横坐标

int y;//纵坐标

int f;//纪录当下的编号，有时输出路径

int sum;//总步数

}；

将开始的位置放入队列，sum=0，每一种可能判断，若能走标志并且进入队列，此时sum+1；一个位置的所有动作完成后，队列head出列；若查找到，退出，此时的总步数为queue【tail-1】.sum；

放题

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!

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<queue>
 using namespace std;
 struct Node
 {
     int x,y,z;
     int sum;

 };
 int  L,R,C;
 char mapa[][][];
 int book[][][];
 void bfs(int a,int b,int c)
 {
     int next[][]={,,,-,,,,,,,-,,,,,,,-};
     queue<Node> s;
     Node n;
     n.x=a,n.y=b,n.z=c,n.sum=;
     book[a][b][c]=;
     s.push(n);
     while(!s.empty())
     {

         for(int i=;i<;i++)
         {
             Node m=s.front();
             Node kk;
             int t1=kk.x=m.x+next[i][];
             int t2=kk.y=m.y+next[i][];
             int t3=kk.z=m.z+next[i][];
             kk.sum=m.sum+;
             if(t1<||t2<||t3<||t1>L||t2>R||t3>C)
                 continue;
             if(mapa[t1][t2][t3]=='E')
             {
                 cout<<"Escaped in "<<kk.sum<<" minute(s)."<<endl;
                 return ;

             }
             if(mapa[t1][t2][t3]=='.'&&book[t1][t2][t3]==)
             {

                 s.push(kk);
                 book[t1][t2][t3]=;

             }

         }
         s.pop();

     }
     cout<<"Trapped!"<<endl;
 }
 int main()
 {

     while(cin>>L>>R>>C)
     {
         int a,b,c;
         if(!L&&!R&&!C)
             break;
             for(int i=;i<=L;i++)
               for(int j=;j<=R;j++)
                 for(int k=;k<=C;k++)
         {
             cin>>mapa[i][j][k];
             if(mapa[i][j][k]=='S') {a=i,b=j,c=k;}

         }
         memset(book,,sizeof(book));
         bfs(a,b,c);

     }

   return ;

 }