诡异的楼梯 BFS hdu 1180

于 2019-08-14 06:49:56 发布
阅读量88 收藏
点赞数
原文链接：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
关注
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},
HDU 1180 诡异的楼梯 BFS
xcatf的博客
09-02 252
诡异的楼梯 Description Hogwarts正式开学以后,Harry发现在Hogwarts里,某些楼梯并不是静止不动的，相反,他们每隔一分钟就变动一次方向. 比如下面的例子里,一开始楼梯在竖直方向,一分钟以后它移动到了水平方向,再过一分钟它又回到了竖直方向.Harry发现对他来说很难找到能使得他最快到...
hdu 诡异的楼梯（BFS）
Darkarts
01-09 2002
诡异的楼梯 Problem Description Hogwarts正式开学以后,Harry发现在Hogwarts里,某些楼梯并不是静止不动的，相反,他们每隔一分钟就变动一次方向.  比如下面的例子里,一开始楼梯在竖直方向,一分钟以后它移动到了水平方向,再过一分钟它又回到了竖直方向.Harry发现对他来说很难找到能使得他最快到达目的地的路线,这时Ron(Harry最好的朋友)
hdu 1180 诡异的楼梯 bfs
diaopi1575的博客
12-20 90
简单的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 456
Hogwarts正式开学以后,Harry发现在Hogwarts里,某些楼梯并不是静止不动的，相反,他们每隔一分钟就变动一次方向. 比如下面的例子里,一开始楼梯在竖直方向,一分钟以后它移动到了水平方向,再过一分钟它又回到了竖直方向.Harry发现对他来说很难找到能使得他最快到达目的地的路线,这时Ron(Harry最好的朋友)告诉Harry正好有一个魔法道具可以帮助他寻找这样的路线,而那个魔法道具
hdu1180诡异的楼梯(bfs)
奋斗的Die Young
05-05 317
题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1180 这个题真的是坑啊。。 等楼梯的时候要看看对面是否已经访问过了，如果访问过了，就没有必要过楼梯了。。。。 这点很重要。。。。 代码： #include #include #include using namespace std; char s[30][30]
HDU 1180 诡异的楼梯 （BFS）
LzyRapX
06-02 597
诡异的楼梯 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
HDU1180-诡异的楼梯（BFS）
QAQ
07-29 806
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1180 题目大意：一个走迷宫问题，求到达出口的最短时间，典型的bfs问题。不过迷宫中有会变方向的桥，如果通过楼梯走了两个格但是时间却还是一分钟。也就是走楼梯可以让你走的更快，是一个捷径。 由于楼梯方向是会变化的，需要判断是否可以通过楼梯，这与走的方向和此时楼梯的方向有关。如果两个方向相同，就...
ACM-BFS之诡异的楼梯——hdu1180
继续激情，继续奋斗。
02-25 1895
bfs 广度优先搜索 hdu1180
HDU图论题目分类
04-18
* 题目1180：诡异的楼梯，涉及到图的单源最短路径概念。 7. 图的最小生成树：图的最小生成树算法、图的 Kruskal 算法等。 * 题目1195：Open the Lock，涉及到图的最小生成树算法。 * 题目1198：Farm Irrigation，...
HDU1180-BFS
CSDN
03-02 1542
诡异的楼梯 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/65536 K (Java/Others) Total Submission(s): 7782    Accepted Submission(s): 1875 Problem Description Hogwarts正式开学以后,Harry发现在
HDOJ 1180 诡异的楼梯 DFS
R_xiaozhu_Q的专栏
05-30 1142
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1180 用DFS很容易超时，尽管题中已经考虑了剪枝，还是超了 1000MS，这题有BFS的高效解法，不过感觉时间限制太小了，1000MS就超了，上次做的题，用BFS 2000MS还能 AC啊，先上代码，思路：重点考虑到达楼梯周围四个点时候的楼梯方向和四个位置，依次枚举。 #include #
基于SpringBoot仿天猫购物系统.zip(毕设&课设&实训&大作业&竞赛&项目)
09-20
项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全领域），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助。 【资源内容】：包含完整源码+工程文件+说明（如有）等。答辩评审平均分达到96分，放心下载使用！可轻松复现，设计报告也可借鉴此项目，该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 【提供帮助】：有任何使用问题欢迎随时与我联系，我会及时解答解惑，提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【项目价值】：可用在相关项目设计中，皆可应用在项目、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面，可借鉴此优质项目实现复刻，设计报告也可借鉴此项目，也可基于此项目来扩展开发出更多功能 下载后请首先打开README文件（如有），项目工程可直接复现复刻，如果基础还行，也可在此程序基础上进行修改，以实现其它功能。供开源学习/技术交流/学习参考，勿用于商业用途。质量优质，放心下载使用。
Python网络爬虫与推荐算法新闻推荐平台(毕设&课设&实训&大作业&竞赛&项目)
最新发布
09-20
Python网络爬虫与推荐算法新闻推荐平台：网络爬虫：通过Python实现新浪新闻的爬取，可爬取新闻页面上的标题、文本、图片、视频链接（保留排版） 推荐算法：权重衰减+标签推荐+区域推荐+热点推荐.zip项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全领域），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助。 【资源内容】：包含完整源码+工程文件+说明（如有）等。答辩评审平均分达到96分，放心下载使用！可轻松复现，设计报告也可借鉴此项目，该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 【提供帮助】：有任何使用问题欢迎随时与我联系，我会及时解答解惑，提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【项目价值】：可用在相关项目设计中，皆可应用在项目、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面，可借鉴此优质项目实现复刻，设计报告也可借鉴此项目，也可基于此项目来扩展开发出更多功能 下载后请首先打开README文件（如有），项目工程可直接复现复刻，如果基础还行，也可在此程序基础上进行修改，以实现其它功能。供开源学习/技术交流/学习参考，勿用于商业用途。质量优质，放心下载使用。
THUCNews数据集
09-20
THUCNews数据集
Q音：Vue3+Pinia+Vue Router4+Vant4的移动端仿抖音短视频项目.zip(毕设&课设&实训&大作业&竞赛&
09-20
项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全领域），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助。 【资源内容】：包含完整源码+工程文件+说明（如有）等。答辩评审平均分达到96分，放心下载使用！可轻松复现，设计报告也可借鉴此项目，该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 【提供帮助】：有任何使用问题欢迎随时与我联系，我会及时解答解惑，提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【项目价值】：可用在相关项目设计中，皆可应用在项目、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面，可借鉴此优质项目实现复刻，设计报告也可借鉴此项目，也可基于此项目来扩展开发出更多功能 下载后请首先打开README文件（如有），项目工程可直接复现复刻，如果基础还行，也可在此程序基础上进行修改，以实现其它功能。供开源学习/技术交流/学习参考，勿用于商业用途。质量优质，放心下载使用。
undo-log.sql
09-20
undo-log.sql
使用 BFS 解决经典搜索问题
Ahdu1548题目利用广度优先搜索（BFS）解决一个问题，而Bpoj2488则涉及到深度优先搜索（DFS）的应用。" 在Ahdu1548问题中，题目要求使用BFS算法来解决。BFS是一种在图或树中搜索的算法，它按照层次顺序遍历节点，即...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值