JOBDU-OJ 1456 胜利大逃亡

题目描述：
Ignatius被魔王抓走了,有一天魔王出差去了,这可是Ignatius逃亡的好机会.魔王住在一个城堡里,城堡是一个A*B*C的立方体,可以被表示成A个B*C的矩阵,刚开始Ignatius被关在(0,0,0)的位置,离开城堡的门在(A-1,B-1,C-1)的位置,现在知道魔王将在T分钟后回到城堡,Ignatius每分钟能从一个坐标走到相邻的六个坐标中的其中一个.现在给你城堡的地图,请你计算出Ignatius能否在魔王回来前离开城堡(只要走到出口就算离开城堡,如果走到出口的时候魔王刚好回来也算逃亡成功),如果可以请输出需要多少分钟才能离开,如果不能则输出-1.
输入：
输入数据的第一行是一个正整数K,表明测试数据的数量.每组测试数据的第一行是四个正整数A,B,C和T(1<=A,B,C<=50,1<=T<=1000),它们分别代表城堡的大小和魔王回来的时间.然后是A块输入数据(先是第0块,然后是第1块,第2块……),每块输入数据有B行,每行有C个正整数,代表迷宫的布局,其中0代表路,1代表墙。
输出：
对于每组测试数据,如果Ignatius能够在魔王回来前离开城堡,那么请输出他最少需要多少分钟,否则输出-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

---

这是一道BFS题，求得是最少耗时（最优化求解），BFS时求解树的深度与用时成线性关系，即先访问到的结点用时一定不小于后访问到的节点。由于图中可能出现环路，之前访问过的节点在以后可能还会访问到，所以用mark[][][]来标记某个节点是否访问过，如果访问过则不再访问它，通过这样来剪枝，使求解树的规模大大降低。

解题时注意一些特殊情况的处理，可以减小时间：

if( maze[0][0][0] || maze[a-1][b-1][c-1]){  //如果入口和出口为墙，则出不去
        return -1;
    }
    if( a+b+c-3 > t){                           //如果入口到出口的最短路径大于所需时间，则出不去
        return -1;
    }

#include<stdio.h>
#include<queue>
using namespace std;

#define MAXNUM 50

int maze[MAXNUM][MAXNUM][MAXNUM];   //迷宫
int mark[MAXNUM][MAXNUM][MAXNUM];   //标记数组，如果maze[i][j][k]已经访问过，则标记为1
int move[6][3] = {
    1,0,0,
    -1,0,0,
    0,1,0,
    0,-1,0,
    0,0,1,
    0,0,-1
};

struct Position{
    int x,y,z,t;
};

queue<Position> Q;

int A,B,C,T,N;

bool check(int x, int y, int z){    //判断当前坐标是否可通过
    if( (x>=A) || (x<0) || 
        (y>=B) || (y<0) || 
        (z>=C) || (z<0) || 
        (maze[x][y][z] == 1) ||
        (mark[x][y][z] == 1)) {     //如果在边界以外，或者此处为墙, 或者已被访问过，则此处访问非法
        return false;
    }
    return true;
}



int bfs(int a, int b, int c, int t){    //返回值为走出迷宫的时间，走不出返回-1
    if( maze[0][0][0] || maze[a-1][b-1][c-1]){  //如果入口和出口为墙，则出不去
        return -1;
    }
    if( a+b+c-3 > t){                           //如果入口到出口的最短路径大于所需时间，则出不去
        return -1;
    }
    int nx,ny,nz;
    mark[0][0][0] = 1;

    if(A == B == C == 1){               //如果入口和出口在同一个点，这返回0时间   
        return 0;
    }

    Position pos = {0,0,0,0};
    Position posNow;
    Q.push(pos);

    while(!Q.empty()){
        pos = Q.front();
        Q.pop();

        if(pos.t>=t)    //如果在此时走到队列最前面的点已经用时t了，还没有走出去，则超时走不出去了
            return -1;

        for(int j=0; j<6; j++){
            //获得移动后的坐标
            nx = pos.x + move[j][0];
            ny = pos.y + move[j][1];
            nz = pos.z + move[j][2];

            //检查是否合法
            if( check(nx,ny,nz) ){

                if(nx == a-1 && ny == b-1 && nz == c-1){    //如果到终点，返回当前时间
                    return pos.t + 1;
                }

                mark[nx][ny][nz] = 1;   //标记来过

                posNow.x=nx;
                posNow.y=ny;
                posNow.z=nz;
                posNow.t=pos.t + 1;

                Q.push(posNow);
            }else continue;
        }
    }
    return -1;  //如果走到

}


int main(){
    scanf("%d", &N);

    while(N--){
        scanf("%d%d%d%d",&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++){
                    scanf("%d", &maze[i][j][k]);    //初始化
                    mark[i][j][k] = 0;
                }
        while(!Q.empty())   //初始化队列
            Q.pop();

        printf("%d\n", bfs(A,B,C,T));
    }
    return 0;
}

总结：如果一个题目可以抽象成图的遍历，且要求最优解，那么可以考虑使用BFS。使用BFS一定要根据题目条件进行剪枝，否则可能会超时。