hdu 1180 诡异的楼梯【BFS+优先队列】

最新推荐文章于 2021-10-31 14:15:53 发布
最新推荐文章于 2021-10-31 14:15:53 发布
阅读量418 收藏
点赞数
分类专栏： 搜索 文章标签： hdu 1180 杭电 1180
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mengxiang000000/article/details/50760963
版权

诡异的楼梯

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/65536 K (Java/Others)
Total Submission(s): 11695    Accepted Submission(s): 2897

Problem Description
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
   
   

   
    
地图如下：

这个题难想的地方是原地不动的情况。如果这个情况考虑到了，其实问题也就解决了。

之所以用到了优先队列，其原因就是有原地不动的情况，所以我们这里控制时间最优，使用优先队列。

思路：
从起点出发，控制楼梯方向和走向，然后根据当前走的时间判断楼梯方向，然后走向的方向如果能够顺着楼梯走下去，那就走两次。

这里口述可能并不是很清楚，这里对应代码：

void bfs(int x,int y)
{
    memset(vis,0,sizeof(vis));
    vis[x][y]=1;
    now.x=x;
    now.y=y;
    now.output=0;
    priority_queue<zuobiao>s;
    s.push(now);
    while(!s.empty())
    {
        now=s.top();
        //printf("%d %d %d\n",now.x,now.y,now.output);
        if(a[now.x][now.y]=='T')
        {
            printf("%d\n",now.output);
            return ;
        }
        s.pop();
        for(int i=0;i<5;i++)//0-右、1-左、2、下、3、上。
        {
            if(i==4)
            {
                nex.x=now.x;
                nex.y=now.y;
                nex.output=now.output+1;
                s.push(nex);
                continue;
            }
            nex.x=now.x+fx[i];
            nex.y=now.y+fy[i];
            if(nex.x>=0&&nex.x<n&&nex.y>=0&&nex.y<m&&a[nex.x][nex.y]!='*'&&vis[nex.x][nex.y]==0)//必须在能走的条件下，才能走向下一步
            {
                if(a[nex.x][nex.y]=='.'||a[nex.x][nex.y]=='T')
                {
                    nex.output=now.output+1;
                    vis[nex.x][nex.y]=1;
                    s.push(nex);
                }
                if(a[nex.x][nex.y]=='|')//0-右、1-左、2、下、3、上。
                {
                    //printf("%d\n",now.output);
                    if(now.output%2==0&&i==2||i==3&&now.output%2==0)//如果当前走的时间是偶数，相当于梯子没有动
                    {
                        //printf("yes\n");
                        nex.x=now.x+2*fx[i];//对应走的方向走两次（题干要求）
                        nex.y=now.y+2*fy[i];
                        if(nex.x>=0&&nex.x<n&&nex.y>=0&&nex.y<m&&a[nex.x][nex.y]!='*'&&vis[nex.x][nex.y]==0)//并且走到的地方也是可行的地方
                        {
                            //printf("%d %d\n",nex.x,nex.y);
                            nex.output=now.output+1;
                            vis[nex.x][nex.y]=1;
                            s.push(nex);
                        }
                    }
                    if(now.output%2==1&&i==0||i==1&&now.output%2==1)
                    {
                       // printf("yes2\n");
                        //printf("%d %d\n",now.output,i);
                        nex.x=now.x+2*fx[i];
                        nex.y=now.y+2*fy[i];
                        if(nex.x>=0&&nex.x<n&&nex.y>=0&&nex.y<m&&a[nex.x][nex.y]!='*'&&vis[nex.x][nex.y]==0)
                        {
                            nex.output=now.output+1;
                            vis[nex.x][nex.y]=1;
                            s.push(nex);
                        }
                    }
                }
                if(a[nex.x][nex.y]=='-')//0-右、1-左、2、下、3、上。
                {
                    if(now.output%2==0&&i==0||i==1&&now.output%2==0)
                    {
                        nex.x=now.x+2*fx[i];
                        nex.y=now.y+2*fy[i];
                        if(nex.x>=0&&nex.x<n&&nex.y>=0&&nex.y<m&&a[nex.x][nex.y]!='*'&&vis[nex.x][nex.y]==0)
                        {
                            nex.output=now.output+1;
                            vis[nex.x][nex.y]=1;
                            s.push(nex);
                        }
                    }
                    if(now.output%2==1&&i==2||i==3&&now.output%2==1)
                    {
                        nex.x=now.x+2*fx[i];
                        nex.y=now.y+2*fy[i];
                        if(nex.x>=0&&nex.x<n&&nex.y>=0&&nex.y<m&&a[nex.x][nex.y]!='*'&&vis[nex.x][nex.y]==0)
                        {
                            nex.output=now.output+1;
                            vis[nex.x][nex.y]=1;
                            s.push(nex);
                        }
                    }
                }
            }
        }
    }
    return ;
}
把这么些个情况都考虑到之后，整个思路缜密一些，题目就能够AC了： 

#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
struct zuobiao
{
    int x,y,output;
    friend bool operator <(zuobiao a,zuobiao b)
    {
        return a.output>b.output;
    }
}now,nex;
int n,m;
int vis[50][50];
char a[50][50];
int fx[4]={0,0,1,-1};//0-右、1-左、2、下、3、上。
int fy[4]={1,-1,0,0};
void bfs(int x,int y)
{
    memset(vis,0,sizeof(vis));
    vis[x][y]=1;
    now.x=x;
    now.y=y;
    now.output=0;
    priority_queue<zuobiao>s;
    s.push(now);
    while(!s.empty())
    {
        now=s.top();
        //printf("%d %d %d\n",now.x,now.y,now.output);
        if(a[now.x][now.y]=='T')
        {
            printf("%d\n",now.output);
            return ;
        }
        s.pop();
        for(int i=0;i<5;i++)//0-右、1-左、2、下、3、上。
        {
            if(i==4)
            {
                nex.x=now.x;
                nex.y=now.y;
                nex.output=now.output+1;
                s.push(nex);
                continue;
            }
            nex.x=now.x+fx[i];
            nex.y=now.y+fy[i];
            if(nex.x>=0&&nex.x<n&&nex.y>=0&&nex.y<m&&a[nex.x][nex.y]!='*'&&vis[nex.x][nex.y]==0)
            {
                if(a[nex.x][nex.y]=='.'||a[nex.x][nex.y]=='T')
                {
                    nex.output=now.output+1;
                    vis[nex.x][nex.y]=1;
                    s.push(nex);
                }
                if(a[nex.x][nex.y]=='|')//0-右、1-左、2、下、3、上。
                {
                    //printf("%d\n",now.output);
                    if(now.output%2==0&&i==2||i==3&&now.output%2==0)
                    {
                        //printf("yes\n");
                        nex.x=now.x+2*fx[i];
                        nex.y=now.y+2*fy[i];
                        if(nex.x>=0&&nex.x<n&&nex.y>=0&&nex.y<m&&a[nex.x][nex.y]!='*'&&vis[nex.x][nex.y]==0)
                        {
                            //printf("%d %d\n",nex.x,nex.y);
                            nex.output=now.output+1;
                            vis[nex.x][nex.y]=1;
                            s.push(nex);
                        }
                    }
                    if(now.output%2==1&&i==0||i==1&&now.output%2==1)
                    {
                       // printf("yes2\n");
                        //printf("%d %d\n",now.output,i);
                        nex.x=now.x+2*fx[i];
                        nex.y=now.y+2*fy[i];
                        if(nex.x>=0&&nex.x<n&&nex.y>=0&&nex.y<m&&a[nex.x][nex.y]!='*'&&vis[nex.x][nex.y]==0)
                        {
                            nex.output=now.output+1;
                            vis[nex.x][nex.y]=1;
                            s.push(nex);
                        }
                    }
                }
                if(a[nex.x][nex.y]=='-')//0-右、1-左、2、下、3、上。
                {
                    if(now.output%2==0&&i==0||i==1&&now.output%2==0)
                    {
                        nex.x=now.x+2*fx[i];
                        nex.y=now.y+2*fy[i];
                        if(nex.x>=0&&nex.x<n&&nex.y>=0&&nex.y<m&&a[nex.x][nex.y]!='*'&&vis[nex.x][nex.y]==0)
                        {
                            nex.output=now.output+1;
                            vis[nex.x][nex.y]=1;
                            s.push(nex);
                        }
                    }
                    if(now.output%2==1&&i==2||i==3&&now.output%2==1)
                    {
                        nex.x=now.x+2*fx[i];
                        nex.y=now.y+2*fy[i];
                        if(nex.x>=0&&nex.x<n&&nex.y>=0&&nex.y<m&&a[nex.x][nex.y]!='*'&&vis[nex.x][nex.y]==0)
                        {
                            nex.output=now.output+1;
                            vis[nex.x][nex.y]=1;
                            s.push(nex);
                        }
                    }
                }
            }
        }
    }
    return ;
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        int qidianx,qidiany;
        for(int i=0;i<n;i++)
        {
            scanf("%s",a[i]);
            for(int j=0;j<m;j++)
            {
                if(a[i][j]=='S')
                {
                    qidianx=i;
                    qidiany=j;
                }
            }
        }
        bfs(qidianx,qidiany);
    }
}










mengxiang000000
关注
专栏目录
hdu1180（广搜+优先队列）
u013509299的专栏
01-25 824
此题要求最少到达目标点T的最短时间，所以我选择了广度优先搜索，并且要用到优先队列。 另外此题注意点较多，比如说可以在某个点停留，我wa了好多两次，就是因为忽略了这一点，然后参考了大神的思想，然后经过反复修改才AC的 这是我的代码 #include #include #include #include #include #include #include #include #i
hdu1180——诡异的楼梯（优先队列+bfs）
huanhuanxiaoxiao的博客
03-19 328
Problem Description Hogwarts正式开学以后,Harry发现在Hogwarts里,某些楼梯并不是静止不动的，相反,他们每隔一分钟就变动一次方向.  比如下面的例子里,一开始楼梯在竖直方向,一分钟以后它移动到了水平方向,再过一分钟它又回到了竖直方向.Harry发现对他来说很难找到能使得他最快到达目的地的路线,这时Ron(Harry最好的朋友)告诉Harry正好有一个魔
HDU1180 诡异的楼梯（BFS+优先队列）
Keep eating codes!
03-01 204
题目链接 题意： 输入M×N大小的地图，'S’是起点，‘T’是目标，’*‘表示障碍物，’.‘表示走廊，’|‘或者’-‘表示一个楼梯,并且标明了它在一开始时所处的位置:’|‘表示的楼梯在最开始是竖直方向,’-'表示的楼梯在一开始是水平方向.楼梯的方向每一个时间单位变化一次，要求从起点到目标的最短时间。 思路： 对于所能扩展的结点分三种情况： （1）走廊：一次位移，一个时间单位 （2）可以通过...
hdu1180 诡异的楼梯（优先队列bfs）
Iguodala的博客
03-05 1848
#include #include #include #include #include using namespace std; const int N = 50; const int INF = 1000000; char Map[N][N]; bool vis[N][N]; int n, m; int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1},
hdu1180 (bfs + 优先队列)
weixin_39548163的博客
08-04 249
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1180 需要用到广搜和优先队列，而本题中的优先队列，就是要使得当前步数小的先出队列 当前坐标结构体的定义 struct node{ int x,y,step; bool operator &lt;(const node &amp;a)const { return step&gt;a.s...
HDU 5040 Instrusive 【BFS+优先队列】
qq_42211531的博客
02-08 236
题意：你需要从M走到T，‘ # ’表示障碍不能走，‘ . ’表示道路，路上有W E N S的四种摄像头,每一秒钟会顺时针旋转一次，你拥有一个纸盒子（藏在纸盒子里不会被看到），你可以藏在纸盒子走需要花费3s，藏在纸盒子里原地不动1s，移动一步1s.到达T点所需要的时间。 思路：很容易想到  bfs+优先队列，如何记录状态呢，摄像头旋转周期的4，到达某一个点摄像头的状态只有4种状态，所以我们用VIS...
HDU 2822 Dogs( BFS + 优先队列)
wcxyky的博客
04-24 161
Problem Description Prairie dog comes again! Someday one little prairie dog Tim wants to visit one of his friends on the farmland, but he is as lazy as his friend (who required Tim to come to his pl...
hdu 2822（BFS+优先队列）
围巾的ACM博客
01-28 866
题意：有一只小狗要去找另一只小狗，两只小狗的坐标都知道，地图里有两种元素，房子(X)还有草地(.)，如果小狗经过房子，则不用花时间，如果经过的是草地，时间+1，最后算出小狗到达目标的时候所花费的最小时间。 思路：因为每个点的权值不一样，所以不能简单的BFS，要用优先队列，时间少的先出队即可 #include #include #include #include #i
hdu1180 诡异的楼梯（BFS+优先队列）
Winjourn的专栏
08-03 1524
题目链接：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(
HDU 1180 诡异的楼梯(BFS+优先队列)
超越自我就是成功
08-15 334
诡异的楼梯 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/65536 K (Java/Others) Total Submission(s): 13186    Accepted Submission(s): 3318 Problem Description Hogwarts正式开学以后,Har
hdu1242(bfs+优先队列)
m0_53024800的博客
10-31 136
和poj2312类似，但是这道题是多个起点一个终点，所以可以选择从终点开始bfs找最近的起点 #include<bits/stdc++.h> using namespace std; char mp[201][201]; int n,m,dx,dy,sx,sy,cnt; bool vis[201][201],flag; int dir[4][4] = {{0,1},{0,-1},{1,0},{-1,0}}; struct Node{ int x,y,step; friend bo.
Catch That Cow-抓住那头牛（BFS+队列）
m0_58245389的博客
07-31 581
Catch That Cow HDU - 2717 Farmer John has been informed of the location of a fugitive cow and wants to catch her immediately. He starts at a point N (0 ≤ N ≤ 100,000) on a number line and the cow is at a point K (0 ≤ K ≤ 100,000) on the same number li...
优先队列BFS
qq_57968062的博客
10-14 446
优先队列 优先队列容器与队列一样，只能从队尾插入元素，从队首删除元素。但是它有一个特性，就是队列中最大的元素总是位于队首，所以出队时，并非按照先进先出的原则进行，而是将当前队列中最大的元素出队。这点类似于给队列里的元素进行了由大到小的顺序排序。元素的比较规则默认按元素值由大到小排序，可以重载“<”操作符来重新定义比较规则，和普通队列不同的是，队首元素是q.top()。 例题 http://acm.hdu.edu.cn/showproblem.php?pid=1242 题意：某人被关在囚笼里等待.
HDU 1044 Collect More Jewels 【经典BFS+DFS】
AC_Dreameng
07-17 2352
Collect More Jewels Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 6597    Accepted Submission(s): 1527 Problem Description It is
优先队列
Grush
09-20 581
知识点讲解详细的博客：http://www.cnblogs.com/heqinghui/archive/2013/07/30/3225407.html 优先级高的先出队列 模板题：HDU 1896 Stones 题意：在一条直的路上有n块石头，遇到第奇数个就将它扔Di的距离，偶数个就在原地不管它，求出发点到最后一个石头的距离 #include #include #include
08-React redux
09-14
redux 相关代码以及 redux 开发者工具
C#中的数据库迁移是如何实现的
09-14
在C#中，数据库迁移是Entity Framework（EF）的一个核心功能，它允许开发者通过代码变更来更新数据库结构。以下是如何在C#中使用Entity Framework实现数据库迁移的详细步骤和代码示例。 Entity Framework的迁移功能为C#开发者提供了一种强大的工具，用于管理和应用数据库架构的变更。通过上述步骤和命令，可以在开发过程中轻松地同步模型和数据库的更改。在实际开发中，应确保在应用迁移之前充分测试，以避免数据丢失或不一致的问题。 在C#中，数据库迁移是Entity Framework（EF）的一个核心功能，它允许开发者通过代码变更来更新数据库结构。以下是如何在C#中使用Entity Framework实现数据库迁移的详细步骤和代码示例。 Entity Framework的迁移功能为C#开发者提供了一种强大的工具，用于管理和应用数据库架构的变更。通过上述步骤和命令，可以在开发过程中轻松地同步模型和数据库的更改。在实际开发中，应确保在应用迁移之前充分测试，以避免数据丢失或不一致的问题。
RS485数据收发程序示例
09-14
RS485数据收发程序示例
基于ssm的闲置图书分享平台系统设计与实现.docx
最新发布
09-14
基于ssm的闲置图书分享平台系统设计与实现.docx
HDU4546 优先队列解法
07-28
对于HDU4546问题，还可以使用优先队列（Priority Queue）来解决。以下是使用优先队列的解法思路： 1. 首先，将数组a进行排序，以便后续处理。 2. 创建一个优先队列（最小堆），用于存储组合之和的候选值。 3. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值