hdu 1253 胜利大逃亡简单三维BFS

最新推荐文章于 2021-02-15 15:21:05 发布

风之轻吟2013

最新推荐文章于 2021-02-15 15:21:05 发布

阅读量726

点赞数

分类专栏： ACM 文章标签：测试 input struct output c

本文链接：https://blog.csdn.net/a656343072/article/details/8044433

版权

ACM 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

这篇博客介绍了一个关于3D迷宫的逃脱问题，玩家需要在魔王返回前找到逃离城堡的最短路径。通过采用广度优先搜索（BFS）算法解决三维迷宫搜索问题，探讨了算法在复杂环境中寻找最优解的效率和应用。案例分析结合了编程技巧和逻辑思维，展示了如何将实际问题转化为算法解决方案。

摘要由CSDN通过智能技术生成

http://acm.hdu.edu.cn/showproblem.php?pid=1253

胜利大逃亡

Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 16298 Accepted Submission(s): 6447

Problem Description

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

Sample Output

Author

Ignatius.L

Recommend

Ignatius.L

看到这个题目后，习惯性的用深搜做了，结果很悲惨的超时了，尽量又花了还是一样。

然后改用不太熟悉的bfs ，纠结的AC了。

这个题目要用bfs的原因我想首先是三维的数据搜索量比较大，同时要求的是能走到终点的最短时间。这时候BFS的优势就体现出来了，

bfs按层次搜索，能够最快的搜索到能够走到终点的最短时间。

下面贴我的代码：

#include <stdio.h>
#include <string.h>
#include <queue>
using namespace std;
#define  INF  99999999

int d[6][3]={{0,0,1},{0,1,0},{1,0,0},{-1,0,0},{0,-1,0},{0,0,-1}};

int Maze[52][52][52];
int T,ct,A,B,C,res;

typedef struct
{
  int x,y,z;
  int time;
}node;

node p,q;

/*void dfs(int x,int y,int z)
{
	if(x==A-1&&y==B-1&&z==C-1)
	{	
		if(ct<min)
			min=ct;
		return ;
	}

	if(x<0||y<0||z<0||x>A-1||y>B-1||z>C-1||ct>T||(A-1-x)+(B-1-y)+(C-1-z)>T)
		return  ;
	for(int i=0;i<=5;i++)              //深搜关键
	{
		if(x+d[i][0]<0||y+d[i][1]<0||z+d[i][2]<0||x+d[i][0]>A-1||y+d[i][1]>B-1||z+d[i][2]>C-1||ct>T)
		    continue ;
		else  if(Maze[x+d[i][0]][y+d[i][1]][z+d[i][2]]==0)
		{
			++ct;
			Maze[x+d[i][0]][y+d[i][1]][z+d[i][2]]=1;
			dfs(x+d[i][0],y+d[i][1],z+d[i][2]);
			Maze[x+d[i][0]][y+d[i][1]][z+d[i][2]]=0;
			--ct;
		}
	}
}*/

void  bfs(int x,int y,int z)
{
	int i,tx,ty,tz,time;
	queue <node>  qu;                     //放到BFS中，开始放在外面WA了一次  因为定义全局队列时当调用时可能不为空的队列
    p.x=x;
	p.y=y;
	p.z=z;
	p.time=0;
	qu.push(p);
	while(!qu.empty())
	{
		q=qu.front();
		qu.pop();
		if(q.time<=T&&q.x==A-1&&q.y==B-1&&q.z==C-1)     //结束条件，BFS相比比DFS的一个好处就是能“最快找到最短的时间”
		{
			res=q.time;
			break;
		}
		for(i=0;i<=5;i++)
		{
			tx=q.x+d[i][0];
			ty=q.y+d[i][1];
			tz=q.z+d[i][2];
			time=q.time+1;
			if(tx>=0&&ty>=0&&tz>=0&&tx<A&&ty<B&&tz<C&&(A+B+C-tx-ty-tz-3<=T-time)&&Maze[tx][ty][tz]==0)    //限制队列元素的插入
			{
				Maze[tx][ty][tz]=1;                                     //注意插入队列后，就把当前点标记
				p.x=tx;
				p.y=ty;
				p.z=tz;
				p.time=time;
				qu.push(p);
			}
		}
	}
}

void print()
{
	int i,j,l;
   for(i=0;i<A;i++)
	 for(j=0;j<B;j++)
	 {
		 for(l=0;l<C;l++)
	  	    printf("%d",Maze[i][j][l]);
		 printf("\n");
	 }
}

int main()
{
	int k,i,j,l;
	scanf("%d",&k);
	while(k--)
	{
	scanf("%d%d%d%d",&A,&B,&C,&T);
	for(i=0;i<A;i++)
      for(j=0;j<B;j++)
		for(l=0;l<C;l++)
		scanf("%d",&Maze[i][j][l]);
	res=INF; 
	bfs(0,0,0);
//	print();
//  dfs(0,0,0);
	if(res==INF)
		printf("-1\n");
	else 
		printf("%d\n",res);
	}
    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

*/