hdu 1180(广搜好题)

诡异的楼梯

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

Problem Description

Hogwarts正式开学以后,Harry发现在Hogwarts里,某些楼梯并不是静止不动的,相反,他们每隔一分钟就变动一次方向.

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

Input

测试数据有多组,每组的表述如下:

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

Output

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

Sample Input

5 5
**..T
**.*.
..|..
.*.*.
S....

Sample Output

7

Hint

Hint

地图如下:

Source

Gardon-DYGG Contest 1

当奇数时间到达‘|‘或‘-‘时,所以这个时候原图的‘|‘会变成‘-‘,所以只能横向走了,‘-‘的话就会变成‘|‘,只能竖着走了。

当偶数时间到达‘|‘或‘-‘时,原图不会变,所以‘|‘还是可以竖着走,‘-‘也是横着走。

最重要的地方来了,这个题目有个隐含条件,我开始没注意到,题目没有不可达的情况!!所以这也暗示了在前面有楼梯的情况下但是楼梯不可达的情况下我们可以在原地等一分钟,这个隐含条件一定要挖掘出来。不然会WA。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<math.h>
#include<queue>
using namespace std;
typedef long long LL;
char graph[25][25];
bool vis[25][25];
struct Node
{
    int x,y,step;
};
Node s,t;
int dir[][2] = {{-1,0},{1,0},{0,-1},{0,1}};
int n,m;
bool check(int x,int y)
{
    if(x<0||x>=n||y<0||y>=m||vis[x][y]||graph[x][y]==‘*‘)
        return false;
    return true;
}
int bfs()
{
    memset(vis,false,sizeof(vis));
    queue<Node> q;
    vis[s.x][s.y]=true;
    q.push(s);
    while(!q.empty())
    {
        Node node = q.front();
        q.pop();
        if(node.x==t.x&&node.y==t.y)
        {
            return node.step;
        }
        Node next;
        for(int i=0; i<4; i++)
        {
            next.x = node.x+dir[i][0];
            next.y = node.y+dir[i][1];
            next.step=node.step+1;
            if(!check(next.x,next.y)) continue;
            if(graph[next.x][next.y]==‘.‘)
            {
                vis[next.x][next.y]=true;
                q.push(next);
            }
            if(graph[next.x][next.y]==‘|‘)
            {
                if((next.step%2==1)&&(i==0||i==1))  ///now this place change to ‘-‘
                {
                    next.x+=dir[i][0];
                    next.y+=dir[i][1];
                    if(check(next.x,next.y)){
                        vis[next.x][next.y]=true;
                        q.push(next);
                    }
                }
                else if((next.step%2==0)&&(i==2||i==3)) ///stay ‘|‘
                {
                    next.x+=dir[i][0];
                    next.y+=dir[i][1];
                    if(check(next.x,next.y)){
                        vis[next.x][next.y]=true;
                        q.push(next);
                    }
                }else{  ///隐含条件,等下一分钟
                    next.x= node.x;
                    next.y = node.y;
                    q.push(next);
                }
            }
            if(graph[next.x][next.y]==‘-‘)
            {
                if((next.step%2==1)&&(i==2||i==3)) ///now this place change to ‘|‘
                {
                    next.x+=dir[i][0];
                    next.y+=dir[i][1];
                    if(check(next.x,next.y)){
                        vis[next.x][next.y]=true;
                        q.push(next);
                    }
                }
                else if((next.step%2==0)&&(i==0||i==1)) ///stay ‘-‘
                {
                    next.x+=dir[i][0];
                    next.y+=dir[i][1];
                    if(check(next.x,next.y)){
                        vis[next.x][next.y]=true;
                        q.push(next);
                    }
                }else{  ///等下一分钟
                    next.x= node.x;
                    next.y = node.y;
                    q.push(next);
                }
            }
        }
    }
    return -1;
}
int main()
{

    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(int i=0; i<n; i++)
        {
            scanf("%s",graph[i]);
            for(int j=0; j<m; j++)
            {
                if(graph[i][j]==‘S‘)
                {
                    s.x = i,s.y = j,s.step=0;
                    graph[i][j]=‘.‘;
                }
                else if(graph[i][j]==‘T‘)
                {
                    t.x = i,t.y = j;
                    graph[i][j]=‘.‘;
                }
            }
        }
        int res = bfs();
        printf("%d\n",res);
    }
    return 0;
}
时间: 2024-11-03 22:38:07

hdu 1180(广搜好题)的相关文章

杭电 1372 Knight Moves(广搜模板题)

http://acm.hdu.edu.cn/showproblem.php?pid=1372 Knight Moves Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 6439    Accepted Submission(s): 3886 Problem Description A friend of you is doing res

hdu 1072 广搜

广搜,用到优先队列,跟hdu1026差不多.但须注意几个问题: 1.可以往回走,由于可以重设时间,有时需要拐弯去“加油”,但可重设时间的结点不能在让它有机会被重走,不然就进入死循环了. 2.队列每次弹出的都是用时最少的,需要自定义排序 #include <iostream> #include <queue> using namespace std; int map[9][9]; int n,m; int dir[4][2]={0,1, 1,0, -1,0, 0,-1}; struc

一道广搜寻路题

同样是在qq群里看到的题目,想了好久算法,实现也用了很久. 关于题目首先看图: 总的来说,就是一个二维迷宫的寻路,迷宫中有对应的钥匙和刺,每走一步会消耗1点Hp,当走到刺上时会额外消耗100点hp,持有对应颜色的钥匙通过刺时不用额外消耗Hp. 给予起点和终点的坐标,,输出移动方式,让人物抵达终点所消耗的Hp尽可能的小. 例子: 3 3 1..a##A...1 13 3这个是输入数据 第一个代表高 第二个宽 第三个是钥匙和陷阱的对数 .代表平地 #代表墙 小写字母是钥匙 大写字母是对应的陷阱输出为

HDU 2717 深搜第一题、

题意:求n到k的最小路径,  n有三种变法 n+1,n-1或者2*n: 贴个广搜的模版在这里把.... 总结一下:一般涉及到求最短路的话用深搜 1 #include<iostream> 2 #include<cstdio> 3 #include<algorithm> 4 #include<queue> 5 #include<cstring> 6 using namespace std; 7 const int qq=1e5+10; 8 int v

HDU 3316 爆搜水题

爆搜水题 模拟扫雷,规则和扫雷一样 给出原图,求在X,Y位置点一下以后的图形,没有弹出的点输出-1,弹出的点输出这个点的数字 从起始点DFS一下即可 #include "stdio.h" #include "string.h" int dir[8][2]={ {-1,0},{-1,1},{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1} }; int n; int hash[110][110]; char str[110][110]; i

广搜简单题

Catch That Cow 题目传送:POJ - 3278 - Catch That Cow 题解:点击即传送 迷宫问题 题目传送:POJ - 3984 - 迷宫问题 DFS也可以,见另一个题解 AC代码(BFS): #include <map> #include <set> #include <cmath> #include <deque> #include <queue> #include <stack> #include &l

广搜模板题马的遍历题解

题目描述 有一个n*m的棋盘(1<n,m<=400),在某个点上有一个马,要求你计算出马到达棋盘上任意一个点最少要走几步 输入格式 一行四个数据,棋盘的大小和马的坐标 输出格式 一个n*m的矩阵,代表马到达某个点最少要走几步(左对齐,宽5格,不能到达则输出-1) 本题思路是利用队列存储,将当前点可到达的下一个点入队以保证步数最小 #include<bits/stdc++.h> using namespace std; int n; int a,b,c,d,k[1001][1001]

HDU 2267 How Many People Can Survive(广搜,简单)

题目 //一道简单的广搜水题 #include<queue> #include<stdio.h> #include<string.h> #include<algorithm> #include<math.h> using namespace std; struct tt { int x,y; }; char mp[310][310]; int vis[310][310]; //看了题解,发现只有4个方向,而不是8个方向....题目貌似都没说清楚

poj 3984:迷宫问题(广搜,入门题)

迷宫问题 Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 7635   Accepted: 4474 Description 定义一个二维数组: int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, }; 它表示一个迷宫,其中的1表示墙壁,0表示可以走的路,只能横着走或竖着走,不能斜着走,要