迷宫问题的求解(广度优先搜索)

     迷宫问题很容易可以理解为广度优先搜索问题,站在一个点上,首先试一试自己周围的点是否可以走,如果是路则加入待走队列,如果是墙则丢弃。迷宫问题在广度优先搜索的时候需要特别注意的就是要及时抛弃,遇到走过的点立即丢弃,遇到墙立即丢弃,不然时间复杂度就很高。

  

题目描述

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

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

<center></center>

输入描述:

输入数据的第一行是一个正整数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++提交.
       

输出描述:

对于每组测试数据,如果Ignatius能够在魔王回来前离开城堡,那么请输出他最少需要多少分钟,否则输出-1.
       

示例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这道题一开始看题看半天,其实它就是3*3*4=36个点,是一个立体的图形,下面的0,1就是表示那个点是路还是墙
 1 #include<stdio.h>
 2 #include<queue>
 3
 4 using namespace std;
 5
 6 bool mark[50][50][50];  //标记数组
 7 int maze[50][50][50];   //保存立方体信息
 8
 9 struct Node
10 {
11     int x,y,z;
12     int t;
13 };
14 queue<Node> Q;
15
16 int go[][3]
17 {
18     1,0,0,
19     -1,0,0,
20     0,1,0,
21     0,-1,0,
22     0,0,1,
23     0,0,-1
24 };
25
26 int BFS(int a,int b,int c)
27 {
28     int i;
29     Node temp;
30     while( Q.empty()==false)
31     {
32         Node now = Q.front();
33         Q.pop();
34         for( i=0; i<6; i++)
35         {
36             //依次扩展6个相邻结点
37             int nx = now.x+go[i][0];
38             int ny = now.y+go[i][1];
39             int nz = now.z+go[i][2];
40             if( nx<0 || nx>=a || ny<0 || ny>=b || nz<0|| nz>=c)
41                 continue;  //若再立方体外则丢弃
42             if( maze[nx][ny][nz]==1)
43                 continue;  //若为墙则丢弃
44             if( mark[nx][ny][nz]==true)
45                 continue;  //若访问过则丢弃
46
47             temp.x = nx;
48             temp.y = ny;
49             temp.z = nz;
50             temp.t = now.t+1;
51             Q.push(temp);   //新位置加入队列中
52             mark[nx][ny][nz] = true;  //标记该位置
53             if( nx==a-1 && ny==b-1 && nz==c-1)
54                 return temp.t;  //到达终点
55         }
56     }
57     return -1;
58 }
59 int main()
60 {
61     int n;
62     int i,j,k;
63     int a,b,c,t;
64     int ret;
65     scanf("%d",&n);
66     while( n--)
67     {
68
69         scanf("%d%d%d%d",&a,&b,&c,&t);
70         for( i=0; i<a; i++)
71         {
72             for( j=0; j<b; j++)
73             {
74                 for( k=0; k<c; k++)
75                 {
76                     scanf("%d",&maze[i][j][k]);
77                     mark[i][j][k] = false;
78                 }
79             }
80         }
81         while( Q.empty()==false) Q.pop();  //清空队列
82         mark[0][0][0] = true;  //标记起点
83         Node temp;
84         temp.t = temp.x = temp.y = temp.z=0;
85         Q.push(temp);
86         ret  = BFS( a,b,c);
87         if( ret<=t) printf("%d\n",ret);   //成功逃出输出时间,无法找到终点输出-1
88         else printf("-1\n");  //若时间超过返回-1
89     }
90     return 0;
91 }


原文地址:https://www.cnblogs.com/yuxiaoba/p/8452000.html

时间: 2024-10-24 12:06:57

迷宫问题的求解(广度优先搜索)的相关文章

迷宫问题 - 队列与广度优先搜索

队列也是一组元素的集合,也提供两种基本操作:Enqueue(入队)将元素添加到队尾,Dequeue(出队)从队头取出元素并返回.就像排队买票一样,先来先服务,先入队的人也是先出队的,这种方式称为FIFO(First In First Out,先进先出),有时候队列本身也被称为FIFO. 下面我们用队列解决迷宫问题.程序如下:(参考<linux c 编程一站式学习>) C++ Code 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 2

迷宫问题 模拟队列 广度优先搜索

Description 定义一个二维数组: int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, }; 它表示一个迷宫,其中的1表示墙壁,0表示可以走的路,只能横着走或竖着走,不能斜着走,要求编程序找出从左上角到右下角的最短路线. Input 一个5 × 5的二维数组,表示一个迷宫.数据保证有唯一解. Output 左上角到右下角的最短路径,格式如样例所示. Sa

迷宫问题(maze problem)——深度优先(DFS)与广度优先搜索(BFS)求解

1.问题简介 给定一个迷宫,指明起点和终点,找出从起点出发到终点的有效可行路径,就是迷宫问题(maze problem). 迷宫可以以二维数组来存储表示.0表示通路,1表示障碍.注意这里规定移动可以从上.下.左.右四方方向移动.坐标以行和列表示,均从0开始,给定起点(0,0)和终点(4,4),迷宫表示如下: int maze[5][5]={ {0,0,0,0,0}, {0,1,0,1,0}, {0,1,1,0,0}, {0,1,1,0,1}, {0,0,0,0,0} }; 那么下面的迷宫就有两条

基于深度及广度优先搜索的迷宫问题的演示

1 时间复杂度分析 由于该图采用邻接矩阵存储,整个算法遍历的过程所花费的时间复杂度为该矩阵的N(row*col).而由于其需要分别访问已经定位,需要进行分别2次操作,如下: visited = new bool[col*row];//访问标记 for (i=0; i<row; i++) for (j=0; j<col; j++) visited[i*col+j] = false;//初始为未访问状态 position = new POSITION[col*row]; for (i=0; i&l

广度优先搜索[再解迷宫]

上一节讲过深度优先搜索解决迷宫,http://blog.csdn.net/wtyvhreal/article/details/43268115 这一节讲解广度优先搜索解决迷宫. 广度优先搜索(Breadth First Search,BFS),也称为宽度优先搜索. 还是二维数组存储,开始小哼在(1,1)处,在深搜里我们先让小哼往右边走,然后一直尝试下去,直到走不通的时候再回到这里.这样是深搜,可以通过函数递归实现.广搜的方法:通过一层一层扩展的方法找到小哈.扩张的时候每发现一个点就将这个点加入到

ybt 1252 广度优先搜索 走迷宫(二维、最小步数)

1252:走迷宫 时间限制: 1000 ms         内存限制: 65536 KB提交数: 7272     通过数: 3241 [题目描述] 一个迷宫由R行C列格子组成,有的格子里有障碍物,不能走:有的格子是空地,可以走. 给定一个迷宫,求从左上角走到右下角最少需要走多少步(数据保证一定能走到).只能在水平方向或垂直方向走,不能斜着走. [输入] 第一行是两个整数,R和C,代表迷宫的长和宽.( 1≤ R,C ≤ 40) 接下来是R行,每行C个字符,代表整个迷宫. 空地格子用‘.’表示,

关于宽搜BFS广度优先搜索的那点事

以前一直知道深搜是一个递归栈,广搜是队列,FIFO先进先出LILO后进后出啥的.DFS是以深度作为第一关键词,即当碰到岔道口时总是先选择其中的一条岔路前进,而不管其他岔路,直到碰到死胡同时才返回岔道口并选择其他岔路.接下来将介绍的广度优先搜索(Breadth First Search, BFS)则是以广度为第一关键词,当碰到岔道口时,总是先一次访问从该岔道口能直接到达的所有节结点,然后再按这些结点被访问的顺序去依次访问它们能直接到达的所有结点,以此类推,直到所有结点都被访问为止.这就跟平静的水面

矩阵图中的广度优先搜索

经常会有类似的题目,如迷宫问题,在一个矩阵图中给定出发点和目标点,每次只能上下左右移动,求到目标点的最短走法,或者说是一共有多少种走法. 思路其实很简单,深搜.广搜.相对比较而言,广度优先搜索更加实用于求最短的走法(步数) 在矩阵图中的广搜需要注意一下几点. 1.确定每步的走法:不同题的走法可能不同,每次搜索时将走法保存在数组中. 2.确定初始状态 往往注意刚开始得起点(i,j)必须把MAP(i,j)改变为 -1(或者其他的),栈中第一个元素即为初始状态 3.保存状态.这点很重要.需要用数组或者

广度优先搜索(BFS)

广度优先 Description: 阿狸被困在迷宫,snoopy要去救他,snoopy可以向上.下.左.右四个方向行走,每走一步(格)就要喝掉一瓶益力多.现在给它一个迷宫地图请问:snoopy最少需要多少瓶益力多才能走出迷宫? Input: 先输入一个数t,表示测试的数据个数, 下面输入的就是t个迷宫, 每个迷宫的输入都应包含以下数据, 输入迷宫的大小 n(n<=15),表示迷宫大小为n*n. 再输入迷宫, 用大写字母“S”表示snoopy的位置, 用小写字母“E”表示阿狸被困的位置, 用“.”