HDU1253 胜利大逃亡 （三维bfs）

Ignatius被魔王抓走了,有一天魔王出差去了,这可是Ignatius逃亡的好机会. 

魔王住在一个城堡里,城堡是一个A*B*C的立方体,可以被表示成A个B*C的矩阵,刚开始Ignatius被关在(0,0,0)的位置,离开城堡的门在(A-1,B-1,C-1)的位置,现在知道魔王将在T分钟后回到城堡,Ignatius每分钟能从一个坐标走到相邻的六个坐标中的其中一个.现在给你城堡的地图,请你计算出Ignatius能否在魔王回来前离开城堡(只要走到出口就算离开城堡,如果走到出口的时候魔王刚好回来也算逃亡成功),如果可以请输出需要多少分钟才能离开,如果不能则输出-1. 

Input输入数据的第一行是一个正整数K,表明测试数据的数量.每组测试数据的第一行是四个正整数A,B,C和T(1<=A,B,C<=50,1<=T<=1000),它们分别代表城堡的大小和魔王回来的时间.然后是A块输入数据(先是第0块,然后是第1块,第2块......),每块输入数据有B行,每行有C个正整数,代表迷宫的布局,其中0代表路,1代表墙.(如果对输入描述不清楚,可以参考Sample Input中的迷宫描述,它表示的就是上图中的迷宫) 

特别注意:本题的测试数据非常大,请使用scanf输入,我不能保证使用cin能不超时.在本OJ上请使用Visual C++提交. 
Output对于每组测试数据,如果Ignatius能够在魔王回来前离开城堡,那么请输出他最少需要多少分钟,否则输出-1. 
Sample Input

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

Sample Output

11

对java不友好啊，加个快速输入输出

代码：

import java.util.*;
import java.util.Comparator;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;
 class Node{
         int x;
         int y;
         int z;
         int step;
         public Node(int x,int y,int z,int step){
                 this.x=x; this.y=y; this.z=z;
                 this.step=step;
         }
 }
public class Main{
    static class FastScanner{//快速输入
        BufferedReader br;
        StringTokenizer st;
        public FastScanner(InputStream in) {
          br = new BufferedReader(new InputStreamReader(in),16384);
          eat("");
        }
        public void eat(String s) {
          st = new StringTokenizer(s);
        }
        public String nextLine() {
          try {
              return br.readLine();
          } catch (IOException e) {
              return null;
          }
        }
        public boolean hasNext() {
          while(!st.hasMoreTokens()) {
              String s = nextLine();
              if(s==null) return false;
              eat(s);
          }
          return true;
        }
        public String next() {
          hasNext();
          return st.nextToken();
        }
        public int nextInt() {
          return Integer.parseInt(next());
        }
    }
    static FastScanner scan = new FastScanner(System.in);//输入
    static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));//输出
        static final int N=55;
        static  int map[][][]=new int[N][N][N];
        static int a,b,c,T;
        static boolean vis[][][]=new boolean[N][N][N];
        static ArrayDeque q=new ArrayDeque();
        static int dx[]={1,-1,0,0,0,0};
        static int dy[]={0,0,1,-1,0,0};
        static int dz[]={0,0,0,0,1,-1};
        static int bfs(){
                while(!q.isEmpty()) q.poll();
                vis[0][0][0]=true;
                q.offer(new Node(0,0,0,0));
                while(!q.isEmpty()){
                        Node s=q.poll();
                        if(s.x==a-1 && s.y==b-1 &&s.z==c-1 &&s.step>T)   return -1;
                        if(s.x==a-1 && s.y==b-1 &&s.z==c-1 &&s.step<=T) return s.step;
                        for(int i=0;i<6;i++){
                                int xx=s.x+dx[i];
                                int yy=s.y+dy[i];
                                int zz=s.z+dz[i];
                                if(xx<0||yy<0||zz<0||xx>=a||yy>=b||zz>=c) continue;
                                if(vis[xx][yy][zz]||map[xx][yy][zz]==1) continue;
                                vis[xx][yy][zz]=true;
                                q.offer(new Node(xx,yy,zz,s.step+1));
                        }
                }
                return -1;
        }
        public static void main(String[] args) {
//                Scanner scan=new Scanner(System.in);
                int t=scan.nextInt();
                while(t-->0){
                        a=scan.nextInt();
                        b=scan.nextInt();
                        c=scan.nextInt();
                        T=scan.nextInt();
                        for(int i=0;i)
                            for(int j=0;j)
                                for(int k=0;k){
                                      map[i][j][k]=scan.nextInt();
                                      vis[i][j][k]=false;
                                }
                        out.println(bfs());
                }
                out.flush();
        }
}