hdu - 1180 诡异的楼梯 (bfs+优先队列)

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

注意点就是楼梯是在harry移动完之后才会改变方向,那么只要统计到达这个点时间奇偶性,就可以知道当前楼梯是水平的还是垂直的。

并且我们需要知道当前到达楼梯这个点的方向,这样才知道下一个往哪个方向走,可以根据dir数组来判断方向。

楼梯不用判重。

#include<stdio.h>
#include<string.h>
#include<queue>
#include<iostream>
using namespace std;

char field[25][25];
int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
int n,m;
struct point
{
    int x,y,time;
    bool operator < (const point a) const
    {
        return time>a.time;
    }
};
point s,e;

bool check(point t)
{
    if(s.x>=0&&s.x<n&&s.y>=0&&s.y<m&&field[s.x][s.y]!=‘*‘)
        return true;
    return false;
}

int bfs()
{
    priority_queue<point>que;
    que.push(s);
    field[s.x][s.y]=‘*‘;
    while(que.size())
    {
        point t=que.top(); que.pop();

        if(t.x==e.x&&t.y==e.y) return t.time;
        for(int i=0;i<4;i++)
        {
            s=t;
            s.x=t.x+dir[i][0];
            s.y=t.y+dir[i][1];
            if(check(s))
            {
                if(field[s.x][s.y]==‘|‘)
                {
                    //printf("%d %d %d %d %d\n",dir[i][0],dir[i][1],t.x,t.y,t.time);
                    if(s.time%2==0)  //偶数 那么 还是 ‘|‘
                    {
                        if(dir[i][0]!=0) //如果是垂直方向只要1分钟就可以到达
                        {
                            s.x+=dir[i][0];
                           // printf("%d %d %d\n",s.x,s.y,s.time);
                            if(!check(s)) continue;
                            s.time+=1;
                           // printf("%d %d %d\n",s.x,s.y,s.time);
                            field[s.x][s.y]=‘*‘;
                            que.push(s);
                        }
                        else   //是水平方向,就要等2秒 因为要等一秒
                        {
                            s.y+=dir[i][1];
                            if(!check(s)) continue;
                            s.time+=2;
                            field[s.x][s.y]=‘*‘;
                            que.push(s);
                        }
                    }
                    else  //奇数 那么变成了 ‘-‘  下面同理
                    {
                        if(dir[i][0]!=0)
                        {
                            s.x+=dir[i][0];
                          //  printf("%d %d %d\n",s.x,s.y,s.time);
                            if(!check(s)) continue;
                            s.time+=2;
                           // printf("%d %d %d\n",s.x,s.y,s.time);
                            field[s.x][s.y]=‘*‘;
                            que.push(s);
                        }
                        else
                        {
                            s.y+=dir[i][1];
                            if(!check(s)) continue;
                            s.time+=1;
                            field[s.x][s.y]=‘*‘;
                            que.push(s);
                        }
                    }
                }
                else if(field[s.x][s.y]==‘-‘)
                {
                    if(s.time%2==0)
                    {
                        if(dir[i][0]!=0)
                        {
                            s.x+=dir[i][0];
                            if(!check(s)) continue;
                            s.time+=2;
                            field[s.x][s.y]=‘*‘;
                            que.push(s);
                        }
                        else
                        {
                            s.y+=dir[i][1];
                            if(!check(s)) continue;
                            s.time+=1;
                            field[s.x][s.y]=‘*‘;
                            que.push(s);
                        }
                    }
                    else
                    {
                        if(dir[i][0]!=0)
                        {
                            s.x+=dir[i][0];
                            if(!check(s)) continue;
                            s.time+=1;
                            field[s.x][s.y]=‘*‘;
                            que.push(s);
                        }
                        else
                        {
                            s.y+=dir[i][1];
                            if(!check(s)) continue;
                            s.time+=2;
                            field[s.x][s.y]=‘*‘;
                            que.push(s);
                        }
                    }
                }
                else
                {
                    s.time+=1;
                    field[s.x][s.y]=‘*‘;
                    que.push(s);
                }
            }
        }
    }
}
int main()
{
    //freopen("a.txt","r",stdin);
    while(~scanf("%d%d",&n,&m))
    {
        getchar();
        for(int i=0;i<n;i++)
        {
            scanf("%s",field[i]);
           // printf("%s\n",field[i]);
            for(int j=0;j<m;j++)
            {
                if(field[i][j]==‘S‘)
                {
                    s.x=i;
                    s.y=j;
                    s.time=0;
                }
                else if(field[i][j]==‘T‘)
                {
                    e.x=i;
                    e.y=j;
                }
            }
        }
        printf("%d\n",bfs());
    }
    return 0;
}
时间: 2024-11-05 11:30:25

hdu - 1180 诡异的楼梯 (bfs+优先队列)的相关文章

hdu 1180 诡异的楼梯 (bfs)

诡异的楼梯 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/65536 K (Java/Others) Total Submission(s): 9360    Accepted Submission(s): 2309 Problem Description Hogwarts正式开学以后,Harry发现在Hogwarts里,某些楼梯并不是静止不动的,相反,他们每隔一分钟就变动一次方向. 比如下面的例子里,一开始楼梯在竖

hdu 1180诡异的楼梯(bfs)

诡异的楼梯 Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 131072/65536K (Java/Other) Total Submission(s) : 49   Accepted Submission(s) : 20 Font: Times New Roman | Verdana | Georgia Font Size: ← → Problem Description Hogwarts正式开学以后,Harry发现在Hogwart

hdu 1180 诡异的楼梯 BFS 这题相当坑爹啊,需要注意几点

诡异的楼梯 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/65536 K (Java/Others) Total Submission(s): 9813    Accepted Submission(s): 2428 Problem Description Hogwarts正式开学以后,Harry发现在Hogwarts里,某些楼梯并不是静止不动的,相反,他们每隔一分钟就变动一次方向. 比如下面的例子里,一开始楼梯在竖

HDU 1180——诡异的楼梯( BFS)

诡异的楼梯 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/65536 K (Java/Others) Total Submission(s): 8717    Accepted Submission(s): 2148 Problem Description Hogwarts正式开学以后,Harry发现在Hogwarts里,某些楼梯并不是静止不动的,相反,他们每隔一分钟就变动一次方向. 比如下面的例子里,一开始楼梯在竖

HDU 1180 诡异的楼梯 (DFS)

诡异的楼梯 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/65536 K (Java/Others) Total Submission(s): 6472    Accepted Submission(s): 1525 Problem Description Hogwarts正式开学以后,Harry发现在Hogwarts里,某些楼梯并不是静止不动的,相反,他们每隔一分钟就变动一次方向. 比如下面的例子里,一开始楼梯在竖

HDU 1180 诡异的楼梯(BFS)

诡异的楼梯 Time Limit:1000MS     Memory Limit:65536KB     64bit IO Format:%I64d & %I64u Submit Status Description Hogwarts正式开学以后,Harry发现在Hogwarts里,某些楼梯并不是静止不动的,相反,他们每隔一分钟就变动一次方向.比如下面的例子里,一开始楼梯在竖直方向,一分钟以后它移动到了水平方向,再过一分钟它又回到了竖直方向.Harry发现对他来说很难找到能使得他最快到达目的地的

HDU 1180 诡异的楼梯 (搜索)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1180 TLE n次.. 注意两点:1,S.T这三种位置是可以停留一秒的.即在没有路可走的时候可以停留一秒. 2, bfs宽搜应该使用优先队列, 并且vis标记加在将next节点push到队列中的时候. 然后就是奇偶判断什么的就可以了. 代码: 1 #define _CRT_SECURE_NO_WARNINGS 2 #include <functional> 3 #include <algor

杭电acm 1180 诡异的楼梯 BFS

诡异的楼梯 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/65536 K (Java/Others)Total Submission(s): 19334    Accepted Submission(s): 5048Problem Description Hogwarts正式开学以后,Harry发现在Hogwarts里,某些楼梯并不是静止不动的,相反,他们每隔一分钟就变动一次方向. 比如下面的例子里,一开始楼梯在竖直

HDOJ/HDU 1180 诡异的楼梯(经典BFS-详解)

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