广度优先搜索（BFS）--胜利大逃亡

广度优先搜索，即在遍历解答树时使每次状态转移时扩展出尽可能多的新状态，并且按照各个状态出现的先后顺序依次扩展。其在解答树上的表现为对解答树的层次遍历。

题目描述：
城堡是一个A*B*C的立方体，可以被表示成A个B*C的矩阵，开始位置为(0,0,0),离开城堡的门在(A-1,B-1,C-1)的位置，
魔王T分钟后回到城堡，Tom每分钟能从一个坐标走到相邻的六个坐标中的一个，请计算Tom能否在回来之前离开城堡。
如果可以，输出需要多少分钟才能离开，不能输出-1.
输入：
第一行整数k，表明测试数据的数量。
四个整数A,B,C,T(1<=A,B,C<=50,1<=T<=1000)，表示城堡大小和回来的时间。
然后是A块输入数据，每块输入数据有B行，每行有C个正整数，代表迷宫的布局，0代表路，1代表墙。
样例输入：
1
3 3 4 20
0 1 1 1
0 0 1 1
0 1 1 1
1 1 1 1
1 0 0 1
0 1 1 1
0 0 0 0
0 1 1 0
0 1 1 0
样例输出：
11
思路：
1.使用结构体保存每一个状态
2.使用队列
3.标记数组mark[x][y][z]，当已经得到过包含(x,y,z)的状态后，即把mark[x][y][z]置为true。
  当下次再有某状态扩展出包含该坐标的状态时，直接丢弃，不对其进行任何处理。
代码如下：

#include <bits/stdc++.h>
using namespace std;

struct N
{
    int x,y,z;//位置坐标
    int t;//所需时间
};
bool mark[50][50][50];
int maze[50][50][50];

queue<N> Q;
int go[][3]={1,0,0,
             -1,0,0,
             0,1,0,
             0,-1,0,
             0,0,1,
             0,0,-1
             };
int BFS(int a,int b,int c)
{
    while(Q.empty()==false)
    {
        N now=Q.front();
        Q.pop();
        for(int i=0;i<6;i++)
        {
            int nx=now.x+go[i][0];
            int ny=now.y+go[i][1];
            int nz=now.z+go[i][2];
            //超过界限，丢弃
            if(nx<0||nx>=a||ny<0||ny>=b||nz<0||nz>=c)
                continue;
            //若为墙壁，丢弃
            if(maze[nx][ny][nz]==1)
                continue;
            //若已经被得到过，丢弃
            if(mark[nx][ny][nz]==true)
                continue;
            N tmp;
            tmp.x=nx;
            tmp.y=ny;
            tmp.z=nz;
            tmp.t=now.t+1;
            Q.push(tmp);
            mark[nx][ny][nz]=true;
            if(nx==a-1&&ny==b-1&&nz==c-1)
                return tmp.t;

        }
    }
    return -1;
}

int main()
{
    int k;
    cin>>k;
    while(k--)
    {
        int a,b,c,t;
        cin>>a>>b>>c>>t;
        for(int i=0;i<a;i++)
        {
            for(int j=0;j<b;j++)
            {
                for(int k=0;k<c;k++)
                {
                    cin>>maze[i][j][k];
                    mark[i][j][k]=false;
                }
            }
        }
        while(Q.empty()==false) Q.pop();
        mark[0][0][0]=true;
        N tmp;
        tmp.t=tmp.x=tmp.y=tmp.z=0;
        Q.push(tmp);
        //BFS(a,b,c);
        int rec=BFS(a,b,c);//广度优先搜索
        //cout<<rec<<endl;
        if(rec<=t)
            cout<<rec<<endl;
        else
            cout<<"-1"<<endl;
    }


    return 0;
}