胜利大逃亡 （九度 OJ 1456）

胜利大逃亡 （九度 OJ 1456）

时间限制：2 秒 内存限制：32 兆 特殊判题：否

1.题目描述：

Ignatius 被魔王抓走了,有一天魔王出差去了,这可是 Ignatius 逃亡的好机会.
魔王住在一个城堡里,城堡是一个 ABC 的立方体,可以被表示成 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

2.基本思路

该问题为一般的搜索问题，可以采用BFS和DFS的搜索方法。这里采用BFS的方法进行搜索，首先维护一个FIFO队列，每次将访问过的结点加入到队列中。结点需要维护位置信息和到达该结点的时间两类信息。利用广度优先搜索的方式来扩展结点，每次都扩展的过程为取队首的结点，向6个方向进行试探，取可达的位置进行扩展。注意需要维护一个mark[N][N][N]用于标识结点是否被访问过。直到取出的结点为目的结点，或者队列为空时循环结束。根据到达目标结点的时间信息判断是否可以逃出。

3.代码实现

#include <iostream>
#include <queue>
#define N 51

using namespace std;

struct P{
    int A,B,C;//该点的空间位置
    int t;//走到改点所需的时间,搜索树的层数
};

int map[N][N][N];
bool mark[N][N][N];//记住要标记访问过的结点，不然会陷入死循环的
queue<P> Q;

int K;
int A,B,C,T;
bool isEscapse=false;

bool inBound(int x,int y,int z){
    if(x>=0&&x<=A-1&&y>=0&&y<=B-1&&z>=0&&z<=C-1)
        return true;
    else
        return false;
}

int main()
{
    scanf("%d",&K);
    for(int i=0;i<K;i++){
        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",&map[i][j][k]);
                    mark[i][j][k]=false;
                }
            }
        }

        while(Q.empty()==false){//每一组数据开始前先清空队列
            Q.pop();
        }

        isEscapse=false;
        P initP;//初始位置
        initP.A=0,initP.B=0,initP.C=0,initP.t=0;
        Q.push(initP);

        while(Q.empty()==false){
            //前

            P p = Q.front();//取出队首元素
            Q.pop();

            if(p.A==A-1&&p.B==B-1&&p.C==C-1){
                if(p.t<=T){
                    printf("%d\n",p.t);
                    isEscapse = true;
                }
                break;
            }
            printf("打印：%d %d %d %d\n",p.A,p.B,p.C,map[p.A][p.B+1][p.C]);
            if(inBound(p.A-1,p.B,p.C)&&map[p.A-1][p.B][p.C]==0&&mark[p.A-1][p.B][p.C]==false){
                P p1;//初始位置
                p1={p.A-1,p.B,p.C,p.t+1};
                Q.push(p1);
                mark[p.A-1][p.B][p.C]=true;
            }
            //后
            if(inBound(p.A,p.B-1,p.C)&&map[p.A][p.B-1][p.C]==0&&mark[p.A][p.B-1][p.C]==false){
                P p2;//初始位置
                p2={p.A,p.B-1,p.C,p.t+1};
                Q.push(p2);
                mark[p.A][p.B-1][p.C]=true;
            }
            //上
            if(inBound(p.A,p.B,p.C-1)&&map[p.A][p.B][p.C-1]==0&&mark[p.A][p.B][p.C-1]==false){
                P p3;//初始位置
                p3={p.A,p.B,p.C-1,p.t+1};
                Q.push(p3);
                mark[p.A][p.B][p.C-1]=true;
            }
            //下
            if(inBound(p.A+1,p.B,p.C)&&map[p.A+1][p.B][p.C]==0&&mark[p.A+1][p.B][p.C]==false){
                P p4;//初始位置
                p4={p.A+1,p.B,p.C,p.t+1};
                Q.push(p4);
                mark[p.A+1][p.B][p.C]=true;
            }
            //左
            if(inBound(p.A,p.B+1,p.C)&&map[p.A][p.B+1][p.C]==0&&mark[p.A][p.B+1][p.C]==false){
                P p5;//初始位置
                p5={p.A,p.B+1,p.C,p.t+1};
                Q.push(p5);
                mark[p.A][p.B+1][p.C]=true;
            }
            //右
            if(inBound(p.A,p.B,p.C+1)&&map[p.A][p.B][p.C+1]==0&&mark[p.A][p.B][p.C+1]==false){
                P p6;//初始位置
                p6={p.A,p.B,p.C+1,p.t+1};
                Q.push(p6);
                mark[p.A][p.B][p.C+1]=true;
            }

        }

        if(isEscapse==false)
            printf("%d\n",-1);

    }
    return 0;
}

/*
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
*/

二刷

#include <iostream>
#include <queue>
#define A 51
#define B 51
#define C 51
using namespace std;

struct Node{
    int x,y,z;
    int t;
};
int dir[6][3] = {{0,0,1},
                 {0,0,-1},
                 {0,1,0},
                 {0,-1,0},
                 {1,0,0},
                 {-1,0,0}};

queue<Node> Q;

int Map[A][B][C];
bool mark[A][B][C];

int main()
{
    int K;
    int a,b,c,T;
    bool flag=false;
    scanf("%d",&K);
    for(int Case=1;Case<=K;Case++){
        flag=false;
        while(!Q.empty())
            Q.pop();
        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",&Map[i][j][k]);
                    mark[i][j][k]=false;//初始化
                }
            }
        }
        Node tmp;
        tmp.t=0,tmp.x=0,tmp.y=0,tmp.z=0;
        Q.push(tmp);
        while(!Q.empty()){
            Node tmp1;
            tmp1 = Q.front();
            Q.pop();
//            printf("tmp1.t=%d\n",tmp1.t);
            if(tmp1.x==a-1&&tmp1.y==b-1&&tmp1.z==c-1){
                if(tmp1.t<=T){
                    printf("%d\n",tmp1.t);
                    flag=true;
                }
                else{
                    flag=false;
                    break;
                }
            }
            for(int i=0;i<6;i++){
                int newx=tmp1.x+dir[i][0];
                int newy=tmp1.y+dir[i][1];
                int newz=tmp1.z+dir[i][2];
                if(mark[newx][newy][newz])continue;//未访问过
                if(newx<0||newx>a-1||newy<0||newy>b-1||newz<0||newz>c-1||Map[newx][newy][newz]==1)continue;//符合限制条件
                Node tmp2;
                tmp2.x=newx;
                tmp2.y=newy;
                tmp2.z=newz;
                tmp2.t=tmp1.t+1;
                Q.push(tmp2);
                mark[newx][newy][newz]=true;
            }

        }
        if(!flag)
                printf("-1\n");

    }
    return 0;
}
/*
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

*/