诡异的楼梯 BFS hdu 1180

于 2019-08-14 06:49:56 发布
阅读量81 收藏
点赞数
原文链接：http://www.cnblogs.com/tangcong/archive/2011/08/09/2131978.html
版权

这题好邪恶啊。做了两个半小时wa得好辛苦。

原因是。。可以停留在空格里的。题意不清啊。

还有就是注意标记。。开了个三维的数组。。分奇数步和偶数步标记。。

最后有可能时间多的先出队。所以要选个最小的时间。。

其实可以用优先队列做。。

艾。。这代码有点太长了。。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <deque>
#include <algorithm>
#include <iostream>

using namespace std;

int a, b, c, d, N, M, t;
char map[50][50];



int hash[3][50][50];

struct node
{
int x, y, t; 
}NODE;

int judge( int x, int y)
{
if (x < 1 || x > N || y < 1|| y > M)
return 0;
return 1;
}


void BFS(  )
{
int i, j, x1, x2, y1, y2, t2, t1;
    deque<node>q;
    memset(hash, 0, sizeof(hash));
    NODE.x = a, NODE.y = b, NODE.t = 0;
//map[a][b]='*';
    hash[0][a][b]=1;
    t = 0x7f7f7f7f;
    q.push_back(NODE);
while (!q.empty( ))
    {
        NODE = q.front( );
        q.pop_front( );
        x1 = NODE.x, y1 = NODE.y, t1 = NODE.t;
//printf("(%d,%d)->%d\n",x1,y1,t1);
        if (x1 == c && y1 == d ) {
if (t1 < t)
            t = t1;
        }
//向右移动 
        x2 = x1 + 0, y2 = y1  + 1, t2 = t1 + 1, NODE.t = 0;
        NODE.x = x2, NODE. y = y2, NODE.t = t2;
if ( judge(x2, y2) && map[x2][y2] != '*' && map[x2][y2] != '-' && map[x2][y2] !='|' && !hash[t2 % 2][x2][y2]) {
            hash[t2%2][x2][y2] = 1;
            q.push_back(NODE);
        }
else if ( (map[x2][y2] == '-' && t1 % 2 == 0 )|| (map[x2][y2] == '|' && t1 % 2 == 1)) {
//NODE.t;
            NODE.y+=1;
            y2 += 1;
if( judge(x2, y2) && map[x2][y2] != '*' && !hash[t2%2][x2][y2])
            {   
                hash[t2%2][x2][y2] = 1;
                q.push_back(NODE);
            }
        }
else if  (map[x2][y2] == '-' || map[x2][y2] == '|') {
//NODE.t;
            NODE.y+=1;
            y2 += 1;
            NODE.t++;
            t2++;
if( judge(x2, y2) && map[x2][y2] != '*' && !hash[t2%2][x2][y2])
            {   
                hash[t2%2][x2][y2] = 1;
                q.push_back(NODE);
            }
        }
//向左移动 
        x2 = x1 + 0, y2 = y1  - 1, t2 = t1 + 1, NODE.t = 0;
        NODE.x = x2, NODE. y = y2, NODE.t = t2;            
if ( judge(x2, y2) && map[x2][y2] != '*' && map[x2][y2] != '-' && map[x2][y2] !='|' && !hash[t2%2][x2][y2]) {
//map[x2][y2] = '*';
            hash[t2%2][x2][y2] = 1;
            q.push_back(NODE);
        }
else if ( (map[x2][y2] == '-' && t1 % 2 == 0 )|| (map[x2][y2] == '|' && t1 % 2 == 1) && !hash[t2%2][x2][y2]) {
//NODE.t++;
            NODE.y-=1;
            y2 -= 1;
if( judge(x2, y2) && map[x2][y2] != '*')
            {   //map[x2][y2]='*';
                hash[t2%2][x2][y2] = 1;
                q.push_back(NODE);
            }
        }
else if  (map[x2][y2] == '-' || map[x2][y2] == '|') {
//NODE.t;
            NODE.y-=1;
            y2 -= 1;
            NODE.t++;
            t2++;
if( judge(x2, y2) && map[x2][y2] != '*' && !hash[t2%2][x2][y2])
            {   
                hash[t2%2][x2][y2] = 1;
                q.push_back(NODE);
            }
        }
//向上移动 
            x2 = x1 - 1, y2 = y1 , t2 = t1 + 1, NODE.t = 0;
            NODE.x = x2, NODE. y = y2, NODE.t = t2;            
if ( judge(x2, y2) && map[x2][y2] != '*' && map[x2][y2] != '-' && map[x2][y2] !='|' && !hash[t2%2][x2][y2]) {
//map[x2][y2] = '*';
            hash[t2%2][x2][y2] = 1;
            q.push_back(NODE);
        }
else if ( (map[x2][y2] == '-' && t1 % 2 == 1 )|| (map[x2][y2] == '|' && t1 % 2 == 0)&& !hash[t2%2][x2][y2]) {
//NODE.t++;
            NODE.x-=1;
            x2 -= 1;
if( judge(x2, y2) && map[x2][y2] != '*')
                {   
//map[x2][y2]='*';
                    hash[t2%2][x2][y2] = 1;
                    q.push_back(NODE);
                }
        }
else if  (map[x2][y2] == '-' || map[x2][y2] == '|') {
            NODE.x-=1;
            x2 -= 1;
            NODE.t++;
            t2++;
if( judge(x2, y2) && map[x2][y2] != '*' && !hash[t2%2][x2][y2])
            {   
                hash[t2%2][x2][y2] = 1;
                q.push_back(NODE);
            }
        }
//向下移动 
            x2 = x1 + 1, y2 = y1 , t2 = t1 + 1, NODE.t = 0;
        NODE.x = x2, NODE. y = y2, NODE.t = t2;            
if ( judge(x2, y2) && map[x2][y2] != '*' && map[x2][y2] != '-' && map[x2][y2] !='|' && !hash[t2%2][x2][y2]) {

            hash[t2%2][x2][y2] = 1;
            q.push_back(NODE);
        }
else if ( (map[x2][y2] == '-' && t1 % 2 == 1 )|| (map[x2][y2] == '|' && t1 % 2 == 0)&& !hash[t2%2][x2][y2]) {
            NODE.x += 1;
            x2 += 1;
if( judge(x2, y2) && map[x2][y2] != '*')
                {  
                   hash[t2%2][x2][y2] = 1;
                   q.push_back(NODE);
                }

        }
else if  (map[x2][y2] == '-' || map[x2][y2] == '|') {
            NODE.x+=1;
            x2 += 1;
            NODE.t++;
            t2++;
if( judge(x2, y2) && map[x2][y2] != '*' && !hash[t2%2][x2][y2])
            {   
                hash[t2%2][x2][y2] = 1;
                q.push_back(NODE);
            }
        }
    }     
}
int main( )
{

int i, j;

while (scanf("%d%d", &N, &M) != EOF)
    {
for (i = 1; i <= N; i++)
for( j = 1; j <= M; j++) {
                 cin>>map[i][j];
if (map[i][j] == 'S')
                 {
                    a = i;
                    b = j;
                }
if (map[i][j] == 'T')
                {
                    c = i;
                    d = j;
                }
            }

        BFS( );
        printf("%d\n",t);
    }
return 0;
}

用优先队列。。。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <deque>
#include <algorithm>
#include <iostream>
#include <queue>

using namespace std;

int a, b, c, d, N, M, t;
char map[50][50];



int hash[3][50][50];

struct node
{
int x, y, t;
bool operator < (const node &A) const
    {
return A.t < t;
    }
}NODE;




int judge( int x, int y)
{
if (x < 1 || x > N || y < 1|| y > M)
return 0;
return 1;
}


void BFS(  )
{
int i, j, x1, x2, y1, y2, t2, t1;
    priority_queue<node>q; //优先队列 
    memset(hash, 0, sizeof(hash));
    NODE.x = a, NODE.y = b, NODE.t = 0;
//map[a][b]='*';
    hash[0][a][b]=1;
    t = 0x7f7f7f7f;
    q.push(NODE);
while (!q.empty( ))
    {
        NODE = q.top( );
        q.pop( );
        x1 = NODE.x, y1 = NODE.y, t1 = NODE.t;
//printf("(%d,%d)->%d\n",x1,y1,t1);
        if (x1 == c && y1 == d ) {
            t = t1;
break;
        }
//向右移动 
        x2 = x1 + 0, y2 = y1  + 1, t2 = t1 + 1, NODE.t = 0;
        NODE.x = x2, NODE. y = y2, NODE.t = t2;
if ( judge(x2, y2) && map[x2][y2] != '*' && map[x2][y2] != '-' && map[x2][y2] !='|' && !hash[t2 % 2][x2][y2]) {
            hash[t2%2][x2][y2] = 1;
            q.push(NODE);
        }
else if ( (map[x2][y2] == '-' && t1 % 2 == 0 )|| (map[x2][y2] == '|' && t1 % 2 == 1)) {
//NODE.t;
            NODE.y+=1;
            y2 += 1;
if( judge(x2, y2) && map[x2][y2] != '*' && !hash[t2%2][x2][y2])
            {   
                hash[t2%2][x2][y2] = 1;
                q.push(NODE);
            }
        }
else if  (map[x2][y2] == '-' || map[x2][y2] == '|') {
//NODE.t;
            NODE.y+=1;
            y2 += 1;
            NODE.t++;
            t2++;
if( judge(x2, y2) && map[x2][y2] != '*' && !hash[t2%2][x2][y2])
            {   
                hash[t2%2][x2][y2] = 1;
                q.push(NODE);
            }
        }
//向左移动 
        x2 = x1 + 0, y2 = y1  - 1, t2 = t1 + 1, NODE.t = 0;
        NODE.x = x2, NODE. y = y2, NODE.t = t2;            
if ( judge(x2, y2) && map[x2][y2] != '*' && map[x2][y2] != '-' && map[x2][y2] !='|' && !hash[t2%2][x2][y2]) {
//map[x2][y2] = '*';
            hash[t2%2][x2][y2] = 1;
            q.push(NODE);
        }
else if ( (map[x2][y2] == '-' && t1 % 2 == 0 )|| (map[x2][y2] == '|' && t1 % 2 == 1) && !hash[t2%2][x2][y2]) {
//NODE.t++;
            NODE.y-=1;
            y2 -= 1;
if( judge(x2, y2) && map[x2][y2] != '*')
            {   //map[x2][y2]='*';
                hash[t2%2][x2][y2] = 1;
                q.push(NODE);
            }
        }
else if  (map[x2][y2] == '-' || map[x2][y2] == '|') {
//NODE.t;
            NODE.y-=1;
            y2 -= 1;
            NODE.t++;
            t2++;
if( judge(x2, y2) && map[x2][y2] != '*' && !hash[t2%2][x2][y2])
            {   
                hash[t2%2][x2][y2] = 1;
                q.push(NODE);
            }
        }
//向上移动 
            x2 = x1 - 1, y2 = y1 , t2 = t1 + 1, NODE.t = 0;
            NODE.x = x2, NODE. y = y2, NODE.t = t2;            
if ( judge(x2, y2) && map[x2][y2] != '*' && map[x2][y2] != '-' && map[x2][y2] !='|' && !hash[t2%2][x2][y2]) {
//map[x2][y2] = '*';
            hash[t2%2][x2][y2] = 1;
            q.push(NODE);
        }
else if ( (map[x2][y2] == '-' && t1 % 2 == 1 )|| (map[x2][y2] == '|' && t1 % 2 == 0)&& !hash[t2%2][x2][y2]) {
//NODE.t++;
            NODE.x-=1;
            x2 -= 1;
if( judge(x2, y2) && map[x2][y2] != '*')
                {   
//map[x2][y2]='*';
                    hash[t2%2][x2][y2] = 1;
                    q.push(NODE);
                }
        }
else if  (map[x2][y2] == '-' || map[x2][y2] == '|') {
            NODE.x-=1;
            x2 -= 1;
            NODE.t++;
            t2++;
if( judge(x2, y2) && map[x2][y2] != '*' && !hash[t2%2][x2][y2])
            {   
                hash[t2%2][x2][y2] = 1;
                q.push(NODE);
            }
        }
//向下移动 
            x2 = x1 + 1, y2 = y1 , t2 = t1 + 1, NODE.t = 0;
        NODE.x = x2, NODE. y = y2, NODE.t = t2;            
if ( judge(x2, y2) && map[x2][y2] != '*' && map[x2][y2] != '-' && map[x2][y2] !='|' && !hash[t2%2][x2][y2]) {

            hash[t2%2][x2][y2] = 1;
            q.push(NODE);
        }
else if ( (map[x2][y2] == '-' && t1 % 2 == 1 )|| (map[x2][y2] == '|' && t1 % 2 == 0)&& !hash[t2%2][x2][y2]) {
            NODE.x += 1;
            x2 += 1;
if( judge(x2, y2) && map[x2][y2] != '*')
                {  
                   hash[t2%2][x2][y2] = 1;
                   q.push(NODE);
                }

        }
else if  (map[x2][y2] == '-' || map[x2][y2] == '|') {
            NODE.x+=1;
            x2 += 1;
            NODE.t++;
            t2++;
if( judge(x2, y2) && map[x2][y2] != '*' && !hash[t2%2][x2][y2])
            {   
                hash[t2%2][x2][y2] = 1;
                q.push(NODE);
            }
        }
    }     
}
int main( )
{

int i, j;

while (scanf("%d%d", &N, &M) != EOF)
    {
for (i = 1; i <= N; i++)
for( j = 1; j <= M; j++) {
                 cin>>map[i][j];
if (map[i][j] == 'S')
                 {
                    a = i;
                    b = j;
                }
if (map[i][j] == 'T')
                {
                    c = i;
                    d = j;
                }
            }

        BFS( );
        printf("%d\n",t);
    }
return 0;
}

转载于:https://www.cnblogs.com/tangcong/archive/2011/08/09/2131978.html

weixin_30455365
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
bfs.rar_hdu
09-22
hdu 3085 一道bfs题 一点值得注意的，鬼魅先走，mm与gg后走，直接模拟这个这个场景，突出时间的先后性，一秒与一秒的区别。。。这样模拟很难出错
hdu1180 诡异的楼梯（优先队列bfs）
Iguodala的博客
03-05 1812
#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},
HDU 1180 诡异的楼梯 BFS
xcatf的博客
09-02 234
诡异的楼梯 Description Hogwarts正式开学以后,Harry发现在Hogwarts里,某些楼梯并不是静止不动的，相反,他们每隔一分钟就变动一次方向. 比如下面的例子里,一开始楼梯在竖直方向,一分钟以后它移动到了水平方向,再过一分钟它又回到了竖直方向.Harry发现对他来说很难找到能使得他最快到...
hdu 诡异的楼梯（BFS）
Darkarts
01-09 1984
诡异的楼梯 Problem Description Hogwarts正式开学以后,Harry发现在Hogwarts里,某些楼梯并不是静止不动的，相反,他们每隔一分钟就变动一次方向.  比如下面的例子里,一开始楼梯在竖直方向,一分钟以后它移动到了水平方向,再过一分钟它又回到了竖直方向.Harry发现对他来说很难找到能使得他最快到达目的地的路线,这时Ron(Harry最好的朋友)
hdu 1180 诡异的楼梯 bfs
diaopi1575的博客
12-20 77
简单的bfs 只是要注意，当楼梯不能通过的时候，可以等带它变过来，这样时间就要加1分钟（位置不变），然后把这个点重新加入队列 View Code #include <stdio.h>#include <queue>using namespace std;struct node{ int x,y,t;}a;int n,m,ex,ey;char ma...
HDU - 1180BFS 诡异的楼梯
你若盛开 清风自来
09-07 442
Hogwarts正式开学以后,Harry发现在Hogwarts里,某些楼梯并不是静止不动的，相反,他们每隔一分钟就变动一次方向. 比如下面的例子里,一开始楼梯在竖直方向,一分钟以后它移动到了水平方向,再过一分钟它又回到了竖直方向.Harry发现对他来说很难找到能使得他最快到达目的地的路线,这时Ron(Harry最好的朋友)告诉Harry正好有一个魔法道具可以帮助他寻找这样的路线,而那个魔法道具
hdu1180诡异的楼梯(bfs)
奋斗的Die Young
05-05 307
题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1180 这个题真的是坑啊。。 等楼梯的时候要看看对面是否已经访问过了，如果访问过了，就没有必要过楼梯了。。。。 这点很重要。。。。 代码： #include #include #include using namespace std; char s[30][30]
HDU1180：诡异的楼梯（BFS）
qq_43555854的博客
01-27 184
诡异的楼梯 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 131072/65536 K (Java/Others) Total Submission(s): 20219 Accepted Submission(s): 5264 Problem Description Hogwarts正式开学以后,Harry发现在Hogwart...
HDU 1180 诡异的楼梯 （BFS）
LzyRapX
06-02 584
诡异的楼梯 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/65536 K (Java/Others) Total Submission(s): 12446    Accepted Submission(s): 3109 Problem Description Hogwarts正式开学以后,Harry发现在H
ACM-BFS之诡异的楼梯——hdu1180
继续激情，继续奋斗。
02-25 1877
bfs 广度优先搜索 hdu1180
BFS.rar_bfs
09-22
BFS变度量算法，.............用于工程中的数值计算
bfs.zip_bfs
09-24
数据结构里的bfs算法，用vc6.0编写
bfs.rar_bFS maze
09-23
用广度搜索方法实现 找迷宫类游戏 从一点搜索到另一点
华为OD机试D卷 - 用连续自然数之和来表达整数 - 免费看解析和代码.html
05-10
私信博主免费获取真题解析以及代码
Screenshot_2024-05-10-20-21-01-857_com.chaoxing.mobile.jpg
05-10
Screenshot_2024-05-10-20-21-01-857_com.chaoxing.mobile.jpg
数字图像处理｜Matlab-频域增强实验-彩色图像的频域滤波.zip
最新发布
05-10
数字图像处理｜Matlab-频域增强实验-彩色图像的频域滤波.zip
2024-2030中国定向转向膜市场现状研究分析与发展前景预测报告.docx
05-10
2024-2030中国定向转向膜市场现状研究分析与发展前景预测报告
开源工时填报管理系统安装包
05-10
开源工时填报管理系统安装包
BFS python
10-11
BFS（广度优先搜索）是一种用于图形遍历的算法，它从起始节点开始，逐层扩展搜索，直到找到目标节点或遍历完整个图形。下面是一个使用Python实现BFS的示例代码： ```python from collections import deque def bfs...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值