2753:走迷宫

题目链接:http://noi.openjudge.cn/ch0205/2753/
总时间限制: 1000ms 内存限制: 65536kB
描述
一个迷宫由R行C列格子组成,有的格子里有障碍物,不能走;有的格子是空地,可以走。
给定一个迷宫,求从左上角走到右下角最少需要走多少步(数据保证一定能走到)。只能在水平方向或垂直方向走,不能斜着走。
输入
第一行是两个整数,R和C,代表迷宫的长和宽。( 1<= R,C <= 40)
接下来是R行,每行C个字符,代表整个迷宫。
空地格子用‘.‘表示,有障碍物的格子用‘#‘表示。
迷宫左上角和右下角都是‘.‘。
输出
输出从左上角走到右下角至少要经过多少步(即至少要经过多少个空地格子)。计算步数要包括起点和终点。
样例输入
5 5
..###
#....
#.#.#
#.#.#
#.#..
样例输出
9

算法分析:

迷宫问题的最短路径,广搜。

 1 #include<stdio.h>
 2 #include<iostream>
 3 #include<queue>
 4 using namespace std;
 5 struct obj
 6 {
 7     int x,y,step;//step表示从出发点到达(i,j)需要的步数 .
 8 };
 9
10 int R,C;
11 char map[42][42];
12 queue<struct obj> q;
13 struct obj Start,End;
14
15 int dx[4]={-1,0,1,0};//上右下左
16 int dy[4]={0,1,0,-1};
17 void BFS();
18
19 int main(int argc, char *argv[])
20 {
21     //freopen("2753.in","r",stdin);
22     int i,j;
23     char c;
24
25     scanf("%d%d",&R,&C);//getchar();//吸收回车
26     while ((c = getchar()) != EOF && c != ‘\n‘);
27     //不停地使用getchar()获取缓冲中字符,直到获取的c是“\n”或文件结尾符EOF为止
28     for(i=0;i<R;i++)
29     {
30         gets(map[i]);
31         /*
32         for(j=0;j<C;j++)
33         {
34             map[i][j]=getchar();
35         }
36         getchar();//吸收回车
37         */
38     }
39     Start.x=0;
40     Start.y=0;
41     Start.step=1;
42     End.x=R-1;
43     End.y=C-1;
44     End.step=-1;
45
46     BFS();
47     printf("%d\n",End.step);
48
49     return 0;
50 }
51
52 void BFS()
53 {
54     int i,txx,tyy;
55     struct obj temp;
56
57     /*while(!q.empty()) q.pop();
58     if(Start.x==End.x&&Start.y==End.y)
59     {
60         End.step=1;
61         return ;
62     }*/
63     q.push(Start);
64     while(!q.empty())
65     {
66         for(i=0;i<4;i++)
67         {
68             txx=q.front().x+dx[i];
69             tyy=q.front().y+dy[i];
70             if(txx>=0&&txx<R&&tyy>=0&&tyy<C&&map[txx][tyy]==‘.‘)
71             {
72                 temp.x=txx;
73                 temp.y=tyy;
74                 temp.step=q.front().step+1;
75                 q.push(temp);
76                 map[txx][tyy]=‘#‘;
77                 if(txx==End.x&&tyy==End.y)
78                 {
79                     End.step=temp.step;
80                     return ;
81                 }
82             }
83         }
84         q.pop();
85     }
86 }
时间: 2024-10-11 21:25:58

2753:走迷宫的相关文章

2753:走迷宫(dfs+初剪)//可以说是很水了。。。

总时间限制:  1000ms 内存限制:  65536kB 描述 一个迷宫由R行C列格子组成,有的格子里有障碍物,不能走:有的格子是空地,可以走.给定一个迷宫,求从左上角走到右下角最少需要走多少步(数据保证一定能走到).只能在水平方向或垂直方向走,不能斜着走. 输入 第一行是两个整数,R和C,代表迷宫的长和宽.( 1<= R,C <= 40)接下来是R行,每行C个字符,代表整个迷宫.空地格子用'.'表示,有障碍物的格子用'#'表示.迷宫左上角和右下角都是'.'. 输出 输出从左上角走到右下角至

NYOJ306 走迷宫(dfs+二分搜索)

题目描述 http://acm.nyist.net/JudgeOnline/problem.php?pid=306 Dr.Kong设计的机器人卡多非常爱玩,它常常偷偷跑出实验室,在某个游乐场玩之不疲.这天卡多又跑出来了,在SJTL游乐场玩个不停,坐完碰碰车,又玩滑滑梯,这时卡多又走入一个迷宫.整个迷宫是用一个N * N的方阵给出,方阵中单元格中填充了一个整数,表示走到这个位置的难度. 这个迷宫可以向上走,向下走,向右走,向左走,但是不能穿越对角线.走迷宫的取胜规则很有意思,看谁能更快地找到一条路

青蛙走迷宫问题(体力值)

题目: 青蛙走迷宫,1代表路通,0代表不通:起点是(0, 0),终点是(0,m - 1);青蛙每次向上走需要消耗体力值为3,向下走不消耗体力值,平走消耗体力值1:根据给定值判断青蛙是否可以根据初始值到达终点,并求出消耗体力值最少的路径: 举例: n = 4, m =4, p = 10(体力值) 4 4 10 1 0 0 1 1 1 0 1 0 1 1 1 0 0 1 1 则结果为:[[0, 0], [1, 0], [1, 1], [2, 1], [2, 2], [2, 3], [1, 3], [

深度优先算法——走迷宫的实现

深度优先搜索算法(Depth-First-Search),是搜索算法的一种.是沿着树的深度遍历树的节点,尽可能深的搜索树的分支.当节点v的所有边都己被探寻过,搜索将回溯到发现节点v的那条边的起始节点.这一过程一直进行到已发现从源节点可达的所有节点为止.如果还存在未被发现的节点,则选择其中一个作为源节点并重复以上过程,整个进程反复进行直到所有节点都被访问为止.属于盲目搜索. 深度优先搜索是图论中的经典算法,利用深度优先搜索算法可以产生目标图的相应拓扑排序表,利用拓扑排序表可以方便的解决很多相关的图

走迷宫

走迷宫 时限:1000ms 内存限制:10000K  总时限:3000ms 描述 判断是否能从迷宫的入口到达出口 输入 先输入两个整数表示迷宫的行数m和列数n,再输入口和出口的坐标,最后分m行输入迷宫,其中1表示墙,0表示空格每个数字之间都有空格. 输出 若能到达,则输出"Yes",否则输出"No",结果占一行. 输入样例 3 30 02 20 0 01 1 00 1 0 输出样例 Yes #include <iostream> using namesp

【老鼠走迷宫二】

/* 老鼠走迷宫二 有问题 */ #include <stdio.h> #include <stdlib.h> void visit(int ,int); int maze[9][9] = { {2, 2, 2, 2, 2, 2, 2, 2, 2}, {2, 0, 0, 0, 0, 0, 0, 0, 2}, {2, 0, 2, 2, 0, 2, 2, 0, 2}, {2, 0, 2, 0, 0, 2, 0, 0, 2}, {2, 0, 2, 0, 2, 0, 2, 0, 2}, {

算法:老鼠走迷宫问题

算法:老鼠走迷宫问题(初) [写在前面] 老鼠走迷宫问题的递归实现,是对递归思想的一种应用. [问题描述] 给定一个二维数组,数组中2表示墙壁,0表示通路,由此数组可展示为一个迷宫图.给定入口位置和出口位置,判断之间是否存在通路并显示出走出迷宫的道路. [代码] 对题目的描述部分 int migo[7][7]={ {2, 2, 2, 2, 2, 2, 2}, {2, 0, 0, 0, 0, 0, 2}, {2, 0, 2, 0, 2, 0, 2}, {2, 0, 0, 0, 0, 2, 2},

数据结构之深度优先搜索(走迷宫)

在此以走迷宫为例: 给定迷宫起点和终点,看能否到达:(xt,yt) void f(int x,int y){ if(x<0||x>21||y<0||y>21){//判断是否超出迷宫 return; } ch[x][y]='#'; for(i=0;i<4;i++){if(ch[x][y]=='.'){ if(x==xt+1&&y==yt+1){ flag=1; return ; } //四个方向 f(x,y+1); f(x,y-1); f(x+1,y); f(x

走迷宫——C++ 算法实现

这两个看了几个不错的走迷宫算法,然后按照自己的方式写了一个实现,代码如下: MyMazeMap.cpp 1 #include <iostream> 2 #include <Windows.h> 3 #include "MazeMap.h" 4 #include "Mazer.h" 5 using namespace std; 6 7 const int SUCCESS = 0; 8 9 int main() 10 { 11 int map[8