HDOJ1180(BFS)

最新推荐文章于 2018-07-29 11:45:43 发布
最新推荐文章于 2018-07-29 11:45:43 发布
阅读量50 收藏
点赞数
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/nickqiao/p/7583406.html
本文介绍了一个基于广度优先搜索(BFS)算法解决哈利波特迷宫问题的方法。迷宫中有可变方向的楼梯，文章详细解释了如何判断角色在奇数或偶数步时的移动可能性，并通过代码实现展示了完整的解决方案。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

题目：

ProblemDescription

Hogwarts正式开学以后,Harry发现在Hogwarts里,某些楼梯并不是静止不动的，相反,他们每隔一分钟就变动一次方向. 
比如下面的例子里,一开始楼梯在竖直方向,一分钟以后它移动到了水平方向,再过一分钟它又回到了竖直方向.Harry发现对他来说很难找到能使得他最快到达目的地的路线,这时Ron(Harry最好的朋友)告诉Harry正好有一个魔法道具可以帮助他寻找这样的路线,而那个魔法道具上的咒语,正是由你纂写的. 

 

 

Input

测试数据有多组，每组的表述如下：
第一行有两个数,M和N,接下来是一个M行N列的地图,'*'表示障碍物,'.'表示走廊,'|'或者'-'表示一个楼梯,并且标明了它在一开始时所处的位置:'|'表示的楼梯在最开始是竖直方向,'-'表示的楼梯在一开始是水平方向.地图中还有一个'S'是起点,'T'是目标,0<=M,N<=20,地图中不会出现两个相连的梯子.Harry每秒只能停留在'.'或'S'和'T'所标记的格子内.

 

 

Output

只有一行,包含一个数T,表示到达目标的最短时间. 
注意:Harry只能每次走到相邻的格子而不能斜走,每移动一次恰好为一分钟,并且Harry登上楼梯并经过楼梯到达对面的整个过程只需要一分钟,Harry从来不在楼梯上停留.并且每次楼梯都恰好在Harry移动完毕以后才改变方向.

 

 

Sample Input

5 5

**..T

**.*.

..|..

.*.*.

S....

 

 

Sample Output

7

 

Hint

Hint

 

地图如下：

分析：BFS。。。。判断走了奇数步还是偶数步，判断是否可以通行，一开始没注意到可以停留，，，代码有点繁琐。。。。。。

代码：

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<cstring>
using namespace std;
int m, n;
char ch[22][22];
int num[22][22];
typedef pair<int, int>P;
int next1[4][2] = { { 0,1 },{ 1,0 },{ 0,-1 },{ -1,0 } };
int bfs(int ax, int ay, int ex, int ey)
{
    queue<P>q; int nx, ny;
    while (!q.empty())
        q.pop();
    q.push(P(ax, ay));
    num[ax][ay] = 1;
    while (!q.empty())
    {
        P fx = q.front();
        if (fx.first == ex&&fx.second == ey)
            return num[ex][ey];
        for (int i = 0; i <=3; i++)
        {
            nx = fx.first + next1[i][0];
            ny = fx.second + next1[i][1];
            if (nx >= 0 && nx < m&&ny >= 0 && ny < n)
            {
                if (ch[nx][ny] == 'T')
                {
                    q.push(P(nx, ny));
                    num[nx][ny] = num[fx.first][fx.second] + 1;
                }
                if (ch[nx][ny] == '.')
                {
                    if (!num[nx][ny])
                    {
                        num[nx][ny] = num[fx.first][fx.second] + 1;
                        q.push(P(nx, ny));
                    }
                }
                if (ch[nx][ny] == '|')
                {
                    
                        if (num[fx.first][fx.second] % 2 != 0)
                        {
                            if (i == 1 && nx + 1 < m&& (ch[nx + 1][ny] == '.' || ch[nx + 1][ny] == 'T'))
                            {
                                if (num[nx + 1][ny])
                                {
                                    if (num[nx + 1][ny] > num[fx.first][fx.second] + 1)
                                        num[nx + 1][ny] = num[fx.first][fx.second] + 1;
                                }
                                    else
                                    {
                                        num[nx + 1][ny] = num[fx.first][fx.second] + 1;
                                        num[nx][ny] = 1;
                                        q.push(P(nx + 1, ny));
                                    }
                            }
                            if (i == 3 && nx - 1 >= 0 && (ch[nx -1][ny] == '.'|| ch[nx - 1][ny] == 'T'))
                            {
                                if (num[nx - 1][ny])
                                {
                                    if (num[nx - 1][ny] > num[fx.first][fx.second] + 1)
                                        num[nx - 1][ny] = num[fx.first][fx.second] + 1;
                                }
                                    else
                                    {
                                        num[nx - 1][ny] = num[fx.first][fx.second] + 1;
                                        num[nx][ny] = 1;
                                        q.push(P(nx - 1, ny));
                                    }
                            }
                            if (i == 2 && ny - 1 >= 0 && (ch[nx][ny - 1] == '.' || ch[nx][ny - 1] == 'T') )
                            {
                                if (num[nx][ny - 1])
                                {
                                    if (num[nx][ny - 1] > num[fx.first][fx.second] +2)
                                        num[nx][ny - 1] = num[fx.first][fx.second] + 2;
                                }
                                    else
                                    {
                                        num[nx][ny - 1] = num[fx.first][fx.second] + 2;
                                        num[nx][ny] = 1;
                                        q.push(P(nx, ny - 1));
                                    }
                            }
                            if (i == 0 && ny + 1 < n && (ch[nx][ny+1] == '.' || ch[nx][ny+1] == 'T') )
                            {
                                if (num[nx][ny + 1])
                                {
                                    if (num[nx][ny + 1] > num[fx.first][fx.second] + 2)
                                        num[nx][ny + 1] = num[fx.first][fx.second] + 2;
                                }
                                    else
                                    {
                                        num[nx][ny + 1] = num[fx.first][fx.second] + 2;
                                        num[nx][ny] = 1;
                                        q.push(P(nx, ny + 1));
                                    }
                            }
                        }
                        if (num[fx.first][fx.second] % 2 == 0)
                        {
                            if (i == 2 && ny - 1 >= 0&&(ch[nx][ny-1]=='.'|| ch[nx][ny - 1] == 'T'))
                            {
                                if (num[nx][ny - 1])
                                {
                                    if (num[nx][ny - 1] > num[fx.first][fx.second] + 1)
                                        num[nx][ny - 1] = num[fx.first][fx.second] + 1;
                                }
                                    else
                                    {
                                        num[nx][ny - 1] = num[fx.first][fx.second] + 1;
                                        num[nx][ny] = 1;
                                        q.push(P(nx, ny - 1));
                                    }
                            }
                            if (i == 0 && ny + 1 < n && (ch[nx][ny + 1] == '.' || ch[nx][ny + 1] == 'T') )
                            {
                                if (num[nx][ny + 1])
                                {
                                    if (num[nx][ny + 1] > num[fx.first][fx.second] + 1)
                                        num[nx][ny + 1] = num[fx.first][fx.second] + 1;
                                }
                                    else
                                    {
                                        num[nx][ny + 1] = num[fx.first][fx.second] + 1;
                                        num[nx][ny] = 1;
                                        q.push(P(nx, ny + 1));
                                    }
                            }
                            if (i == 1 && nx + 1 < m&&(ch[nx + 1][ny] == '.'|| ch[nx + 1][ny] == 'T') )
                            {
                                if (num[nx + 1][ny])
                                {
                                    if (num[nx + 1][ny] > num[fx.first][fx.second] + 2)
                                        num[nx + 1][ny] = num[fx.first][fx.second] + 2;
                                }
                                    else
                                    {
                                        num[nx + 1][ny] = num[fx.first][fx.second] + 2;
                                        num[nx][ny] = 1;
                                        q.push(P(nx + 1, ny));
                                    }
                            }
                            if (i == 3 && nx - 1 >= 0 && (ch[nx - 1][ny] == '.' || ch[nx - 1][ny] == 'T') )
                            {
                                if (num[nx - 1][ny])
                                {
                                    if (num[nx - 1][ny] > num[fx.first][fx.second] + 2)
                                        num[nx - 1][ny] = num[fx.first][fx.second] + 2;
                                }
                                    else
                                    {
                                        num[nx - 1][ny] = num[fx.first][fx.second] + 2;
                                        num[nx][ny] = 1;
                                        q.push(P(nx - 1, ny));
                                    }
                            }
                        }
                    
                }
                if (ch[nx][ny] == '-')
                {
                    
                        if (num[fx.first][fx.second] % 2 == 0)
                        {
                            if (i == 1 && nx + 1 < m&& (ch[nx + 1][ny] == '.' || ch[nx + 1][ny] == 'T')  )
                            {
                                if (num[nx + 1][ny])
                                {
                                    if (num[nx + 1][ny] > num[fx.first][fx.second] + 1)
                                        num[nx + 1][ny] = num[fx.first][fx.second] + 1;
                                }
                                    else
                                    {
                                        num[nx + 1][ny] = num[fx.first][fx.second] + 1;
                                        num[nx][ny] = 1;
                                        q.push(P(nx + 1, ny));
                                    }
                            }
                            if (i == 3 && nx - 1 >= 0 && (ch[nx - 1][ny] == '.' || ch[nx - 1][ny] == 'T'))
                            {
                                if (num[nx - 1][ny])
                                {
                                    if (num[nx - 1][ny] > num[fx.first][fx.second] + 1)
                                        num[nx - 1][ny] = num[fx.first][fx.second] + 1;
                                }
                                    else
                                    {
                                        num[nx - 1][ny] = num[fx.first][fx.second] + 1;
                                        num[nx][ny] = 1;
                                        q.push(P(nx - 1, ny));
                                    }
                            }
                            if (i == 2 && ny - 1 >= 0 && (ch[nx][ny - 1] == '.' || ch[nx][ny - 1] == 'T') )
                            {
                                if (num[nx][ny - 1])
                                {
                                    if (num[nx][ny - 1] > num[fx.first][fx.second] + 2)
                                        num[nx][ny - 1] = num[fx.first][fx.second] + 2;
                                }
                                    else
                                    {
                                        num[nx ][ny-1] = num[fx.first][fx.second] + 2;
                                        num[nx][ny] = 1;
                                        q.push(P(nx, ny-1));
                                    }
                            }
                            if (i == 0 && ny + 1 < n&& (ch[nx][ny + 1] == '.' || ch[nx][ny + 1] == 'T'))
                            {
                                if (num[nx][ny + 1])
                                {
                                    if (num[nx][ny + 1] > num[fx.first][fx.second] + 2)
                                        num[nx][ny + 1] = num[fx.first][fx.second] + 2;
                                }
                                    else
                                    {
                                        num[nx][ny + 1] = num[fx.first][fx.second] + 2;
                                        num[nx][ny] = 1;
                                        q.push(P(nx, ny + 1));
                                    }
                            }
                        }
                        if (num[fx.first][fx.second] % 2 != 0)
                        {
                            if (i == 2 && ny - 1 >= 0 && (ch[nx][ny - 1] == '.'|| ch[nx][ny - 1] == 'T') )
                            {
                                if (num[nx][ny - 1])
                                {
                                    if (num[nx][ny - 1] > num[fx.first][fx.second] + 1)
                                        num[nx][ny - 1] = num[fx.first][fx.second] + 1;
                                }
                                    else
                                    {
                                        num[nx][ny - 1] = num[fx.first][fx.second] + 1;
                                        num[nx][ny] = 1;
                                        q.push(P(nx, ny - 1));
                                    }
                            }
                            if (i == 0 && ny + 1 < n&&(ch[nx][ny + 1] == '.'|| ch[nx][ny + 1] == 'T'))
                            {
                                if (num[nx][ny + 1])
                                {
                                    if (num[nx][ny + 1] > num[fx.first][fx.second] + 1)
                                        num[nx][ny + 1] = num[fx.first][fx.second] + 1;
                                }
                                    else
                                    {
                                        num[nx][ny + 1] = num[fx.first][fx.second] + 1;
                                        num[nx][ny] = 1;
                                        q.push(P(nx, ny + 1));
                                    }
                            }
                            if (i == 1 && nx + 1 < m && (ch[nx + 1][ny] == '.' || ch[nx + 1][ny] == 'T') )
                            {
                                if (num[nx + 1][ny])
                                {
                                    if (num[nx + 1][ny] > num[fx.first][fx.second] + 2)
                                        num[nx + 1][ny] = num[fx.first][fx.second] + 2;
                                }
                                    else
                                    {
                                        num[nx + 1][ny] = num[fx.first][fx.second] + 2;
                                        num[nx][ny] = 1;
                                        q.push(P(nx + 1, ny));
                                    }
                            }
                            if (i == 3 && nx - 1 >= 0 && (ch[nx - 1][ny] == '.' || ch[nx - 1][ny] == 'T') )
                            {
                                if (num[nx - 1][ny])
                                {
                                    if (num[nx - 1][ny] > num[fx.first][fx.second] + 2)
                                        num[nx - 1][ny] = num[fx.first][fx.second] + 2;
                                }
                                    else
                                    {
                                        num[nx - 1][ny] = num[fx.first][fx.second] + 2;
                                        num[nx][ny] = 1;
                                        q.push(P(nx - 1, ny));
                                    }
                            }
                        }
                    
                }

            }
        }
        q.pop();
    }
}
int main()
{
    int a, b, c, d;
    while (scanf("%d%d", &m, &n) != EOF)
    {
        memset(num, 0, sizeof(num));
        for (int i = 0; i < m; i++)
            scanf("%s", ch[i]);
        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++)
            {
                if (ch[i][j] == 'S')
                {
                    a = i; b = j;
                }
                if (ch[i][j] == 'T')
                {
                    c = i; d = j;
                }
            }
        printf("%d\n", bfs(a, b, c, d) - 1);
    }
    return 0;    
}


转载于:https://www.cnblogs.com/nickqiao/p/7583406.html

HDOJ 1180: 诡异的楼梯
frog的小池塘
07-06 1619
其实这是一道水题，因为有人问所以做了一下。 第一次知道HDOJ AC数1000+的题目我也可以写将近一个小时。。 俗话说的好，做水题伤身。 俗话又说的好，做水题还犯脑残错误更伤身。 俗话还说的好，脑残无药医啊啊啊啊啊啊啊啊 题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1180 题目大意： 给定一个n*m的地图，给定了起
HDOJ 1728 逃离迷宫（BFS，拐弯次数最少）
xx_ii
08-09 2249
HDOJ 1728开始拿到这道题，想到先前写过的BFS，由出口到终点，最短路径。后来一看题目不是这个意思，题目要求拐弯数最少到达终点而不是求最短路径。 看了解题报告，有了一点点思路，就是先选定一条方向，然后把该方向上所有能拐的弯都拐了。也就是说，运动的方向不仅仅是周围的四个点，因为没求最短时间，为了避免BFS提前结束，就把四个方向搜索到底。 注意，这里记录拐弯数的K的初始值不是0而是-1，因为第
BFS+诡异的楼梯
wenlovingliu的专栏
04-13 625
诡异的楼梯 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/65536 K (Java/Others) Total Submission(s): 6132    Accepted Submission(s): 1446 Problem Description Hogwarts正式开学以后,Harry发
HDOJ/HDU 1180 诡异的楼梯(经典BFS-详解)
weixin_34210740的博客
07-10 310
Problem Description Hogwarts正式开学以后,Harry发现在Hogwarts里,某些楼梯并不是静止不动的，相反,他们每隔一分钟就变动一次方向. 比如下面的例子里,一开始楼梯在竖直方向,一分钟以后它移动到了水平方向,再过一分钟它又回到了竖直方向.Harry发现对他来说很难找到能使得他最快到达目的地的路线,这时...
HDOJ 1180 诡异的楼梯 DFS
R_xiaozhu_Q的专栏
05-30 1196
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1180 用DFS很容易超时，尽管题中已经考虑了剪枝，还是超了 1000MS，这题有BFS的高效解法，不过感觉时间限制太小了，1000MS就超了，上次做的题，用BFS 2000MS还能 AC啊，先上代码，思路：重点考虑到达楼梯周围四个点时候的楼梯方向和四个位置，依次枚举。 #include #
ACM HDOJ 课件
10-31
6. **搜索算法**：包括深度优先搜索（DFS）和广度优先搜索（BFS），是解决图论问题和树结构问题的重要工具。课件中会介绍它们的工作原理以及如何在实际问题中应用。 7. **组合博弈论**：这是博弈论的一个分支，研究...
hdoj解题代码
09-12
这些文件是针对“hdoj”（HDU Online Judge）在线编程竞赛平台的解题代码，涵盖了题目编号从1000到1050的若干题目。HDU Online Judge是一个用于训练和测试编程技能的系统，用户可以提交代码解决各种算法问题，并获取...
HDOJ.zip_hduoj100题
09-23
【HDOJ.zip_hduoj100题】是一个压缩包文件，包含了HDUOJ（杭州电子科技大学在线评测系统）的约100道编程练习题目及其源代码。这个资源对于想要提升编程技能，尤其是对算法和数据结构有深入学习需求的程序员来说，是...
HDOJ 1180 诡异的楼梯
小青青的技术之家
04-09 362
点击打开链接 //AC 中间处理有点不懂 #include #include #include #include using namespace std; struct Node { int x, y, step; }; bool operator< ( Node n1, Node n2 ) { return n1.step > n2.step; }
HDOJ 1180
weixin_30823683的博客
08-27 100
我的code: 超时，不知道怎么优化，望大神指点 1 #include<iostream> 2 #include <string> 3 #include <queue> 4 using namespace std; 5 6 struct StepPoint 7 { 8 int X,Y,Val;...
hdoj 1180 诡异的楼梯(BFS)
u014458169的专栏
04-11 454
看似简单，陷阱无数，改了又WA，WA了坚持到底，就是AC。
hdoj-【1180 诡异的楼梯】
有梦的博客
11-19 320
诡异的楼梯 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/65536 K (Java/Others) Total Submission(s): 13517    Accepted Submission(s): 3411 Problem Description Hogwarts正式开学以后,Har
hdu1180（BFS）
pmt123456的博客
12-09 809
题目链接 诡异的楼梯 5 5 **..T **.*. ..|.. .*.*. S.... 如图所示的地图，|代表楼梯，每分钟移动一次方向，只能顺着楼梯的方向走，每次可以在 . 或S或T处停留，求从S到T的最小步数 没有什么难度，在楼梯的地方模拟清楚就行，把方向的各个情况弄清楚 记录时间差，判断到达楼梯时的方向， 当是|的时候，只能沿着上下方向走， 当是—时只能沿着
hdu1180 诡异的楼梯--BFS
半壶老酒
07-19 1166
原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1180 需要注意这句话：Harry每秒只能停留在'.'或'S'和'T'所标记的格子内. #define _CRT_SECURE_NO_DEPRECATE #define _CRT_SECURE_Cy1_OVERLOAD_STANDARD_NAMES 1 #include #inclu
hdoj1180 诡异的楼梯
VitaLemon__的专栏
04-07 488
题意  走迷宫，求最少步数，很容易就想到BFS，而这是一道加了点难度的BFS，但是框架是不变的。唯一的难点就是“梯子”。题意中有两个地方需要理清：   1.梯子可以有很多个   2.人物可以在某个时候选择停止，不走  另外，梯子的方向，是随着时间（或者说走的步数）的增加而进行，因此这里存在一个类似于“奇偶性”的问题。即：   （1）如果梯子开始的时候是“|”，那么走了奇数步之后就会变成“-”，
HDU1180-诡异的楼梯（BFS）
QAQ
07-29 854
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1180 题目大意：一个走迷宫问题，求到达出口的最短时间，典型的bfs问题。不过迷宫中有会变方向的桥，如果通过楼梯走了两个格但是时间却还是一分钟。也就是走楼梯可以让你走的更快，是一个捷径。 由于楼梯方向是会变化的，需要判断是否可以通过楼梯，这与走的方向和此时楼梯的方向有关。如果两个方向相同，就...
hdoj 1180 搜索 + bfs + 优先队列
Unyielding will
12-10 407
题目 #include #include #define MAX 22 #include using namespace std; struct Node{ int x, y, s; friend bool operator<(const Node &a, const Node &b){ return a.s > b.s; } }; int vis[MAX][MAX]; c
hdu1180 诡异的楼梯（BFS+优先队列）
Winjourn的专栏
08-03 1568
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1180 诡异的楼梯 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/65536 K (Java/Others) Total Submission(s): 10827    Accepted Submission(
二分搜索入门与HDOJ-2199解题技巧
- DFS (深度优先搜索) 和 BFS (广度优先搜索)：虽然课程中只提到二分搜索，但DFS和BFS也是搜索算法的重要组成部分，尤其在图论问题中常用。 3. 时间复杂度分析：搜索算法的时间复杂度通常与问题规模有关，如二分...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值