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

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

地图如下:

挺经典的一个广搜题目!

题意很好理解。做的时候理清思路,注意楼梯的方向,楼梯的方向可以用到达时候的时间的奇偶来判断。因为楼梯只有2个方向!上下,或者左右。

移动到楼梯后面也还要判断下是否越界,楼梯对面是不是墙,是不是已经走过,这3个条件,满足了才能过去。

如果到的时候,楼梯方向与过去的方向不同,就只能等待一分钟,在这个时候,位置不动,时间加1!再进入队列。这个顺序很重要!

不能先过去,然后时间加2,再入队列。这样会超内存,这是很多人用优先队列的原因!

(因为这样的话,你会发现,弹出的node型变量的t会出现t-时间小的会在后面弹出,这样增加了内存的使用!!!)

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
struct node{
    int x,y,t;
};
int n,m;
int mx[]={0,1,0,-1};
int my[]={1,0,-1,0};//右,下,左,上
char map[30][30];
int d[30][30];
int tx,ty,sx,sy;
node ft;
int judge(int x,int y){
    if(x<0||x>=n||y<0||y>=m){
        return 0;
    }
    if(d[x][y]){
        return 0;
    }
    if(map[x][y]==‘*‘){
        return 0;
    }
    return 1;
}

void bfs(){
    queue<node> q;
    ft.x=sx;
    ft.y=sy;
    ft.t=0;
    q.push(ft);
    d[sx][sy]=1;
    while(!q.empty()){
        node ff=q.front();
        q.pop();
        int x=ff.x;
        int y=ff.y;
        if(map[x][y]==‘T‘){
            printf("%d\n",ff.t);
            return;
        }
        for(int i=0;i<4;i++){
            x=ff.x+mx[i];
            y=ff.y+my[i];
            if(!judge(x,y)){
                continue;
            }
            node nt;
            if(map[x][y]==‘.‘||map[x][y]==‘T‘){//正常走
                nt.x=x;
                nt.y=y;
                nt.t=ff.t+1;
                d[nt.x][nt.y]=1;
                q.push(nt);
                continue;
            }else if(i==0||i==2){//右和左
                if(map[x][y]==‘-‘&&ff.t%2==0){//可以过去
                    nt.x=x+mx[i];
                    nt.y=y+my[i];
                    if(judge(nt.x,nt.y)){
                        nt.t=ff.t+1;
                        d[nt.x][nt.y]=1;
                        q.push(nt);
                    }
                }else if(map[x][y]==‘|‘&&ff.t%2!=0){
                    nt.x=x+mx[i];
                    nt.y=y+my[i];
                    if(judge(nt.x,nt.y)){
                        nt.t=ff.t+1;
                        d[nt.x][nt.y]=1;
                        q.push(nt);
                    }
                }else {//不能过楼梯,得等一分钟
                    nt.x=ff.x;
                    nt.y=ff.y;
                    nt.t=ff.t+1;
                    d[nt.x][nt.y]=1;
                    q.push(nt);
                }
            }else{//上和下
                if(map[x][y]==‘|‘&&ff.t%2==0){//可以过去
                    nt.x=x+mx[i];
                    nt.y=y+my[i];
                    if(judge(nt.x,nt.y)){
                        nt.t=ff.t+1;
                        d[nt.x][nt.y]=1;
                        q.push(nt);
                    }
                }else if(map[x][y]==‘-‘&&ff.t%2!=0){
                    nt.x=x+mx[i];
                    nt.y=y+my[i];
                    if(judge(nt.x,nt.y)){
                        nt.t=ff.t+1;
                        d[nt.x][nt.y]=1;
                        q.push(nt);
                    }
                }else {//不能过楼梯,得等一分钟
                    nt.x=ff.x;
                    nt.y=ff.y;
                    nt.t=ff.t+1;
                    d[nt.x][nt.y]=1;
                    q.push(nt);
                }
            }
        }
    }
}

int main(){
    while(~scanf("%d%d",&n,&m)){
        memset(d,0,sizeof(d));
        for(int i=0;i<n;i++){
            scanf("%s",map[i]);
            for(int j=0;j<m;j++){
                if(map[i][j]==‘S‘){
                    sx=i,sy=j;
                }
            }
        }
        bfs();
    }
    return 0;
}

测试数据:
/*
3 3
S|.
-..
T..
5 5
**..T
**.*.
..|..
.*.*.
S....
3 4
S|.|
-T-.
.|..
20 20
S.|.|.|.|.|.|.|.|.|.
.|.|.|.|.|.|.|.|.|.|
|.|.|.|.|.|.|.|.|.|.
.|.|.|.|.|.|.|.|.|.|
|.|.|.|.|.|.|.|.|.|.
.|.|.|.|.|.|.|.|.|.|
|.|.|.|.|.|.|.|.|.|.
.|.|.|.|.|.|.|.|.|.|
|.|.|.|.|.|.|.|.|.|.
.|.|.|.|.|.|.|.|.|.|
|.|.|.|.|.|.|.|.|.|.
.|.|.|.|.|.|.|.|.|.|
|.|.|.|.|.|.|.|.|.|.
.|.|.|.|.|.|.|.|.|.|
|.|.|.|.|.|.|.|.|.|.
.|.|.|.|.|.|.|.|.|.|
|.|.|.|.|.|.|.|.|.|.
.|.|.|.|.|.|.|.|.|.|
|.|.|.|.|.|.|.|.|.|.
.|.|.|.|.|.|.|.|.|.T
2 7 7 20
*/
时间: 2024-10-11 20:56:06

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

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 诡异的楼梯(BFS)

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

【HDOJ】1180 诡异的楼梯

bfs+优先队列.wa了N次,才发现可以停留等待楼梯变换方向. 1 #include <iostream> 2 #include <queue> 3 #include <cstdio> 4 #include <cstring> 5 using namespace std; 6 7 #define MAXNUM 55 8 9 typedef struct node_st { 10 int x, y, t; 11 node_st() {} 12 node_st(

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: 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 诡异的楼梯 (搜索)

题目链接: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

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

http://acm.hdu.edu.cn/showproblem.php?pid=1180 注意点就是楼梯是在harry移动完之后才会改变方向,那么只要统计到达这个点时间奇偶性,就可以知道当前楼梯是水平的还是垂直的. 并且我们需要知道当前到达楼梯这个点的方向,这样才知道下一个往哪个方向走,可以根据dir数组来判断方向. 楼梯不用判重. #include<stdio.h> #include<string.h> #include<queue> #include<io