POJ 3322 Bloxorz I 三维BFS

最新推荐文章于 2020-12-09 10:01:17 发布
最新推荐文章于 2020-12-09 10:01:17 发布
阅读量1.8k 收藏
点赞数
分类专栏： 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zmx354/article/details/18883759
版权

本来只是打算为今晚的CF热热手的，结果选了道坑爹的BFS。写了350多行的代码还WA了一次。。。。。

对于普通的方格有五种情况，如下图所示，对于方格5来说，与1，与2，与3，与4组成的矩形为四种不同的情况，还有一种为竖直站立的情况。

对于Easily Broken Cell只存在前四种情况。

很显然第三维标记这几种情况即可。思路还算简单，代码写的比较麻烦了。。。。

话说今年大年三十哇，出去耍会先。


#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <queue>
#include <cmath>
#include <algorithm>

#define LL long long
#define PI (acos(-1.0))
#define EPS (1e-8)

using namespace std;

const int MAXN = 1001000;

bool mark[510][510][5];

char Map[510][510];

struct N
{
    int x,y,ty,ans;
};

int jx[] = {-1, 0, 1, 0};
int jy[] = { 0,-1, 0, 1};

void bfs(int n,int m)
{
    int i,j;

    queue<N> q;

    N s,t;

    memset(mark,false,sizeof(mark));

    for(i = 1,j = m+1;i < n && j == m+1; ++i)
    {
        for(j = 1;j <= m && Map[i][j] != 'X'; ++j)
            ;
    }

    s.x = i-1,s.y = j;

    for(i = 0;i < 4 && Map[s.x+jx[i]][s.y+jy[i]] != 'X'; ++i)
        ;

    s.ty = i;
    s.ans = 0;

    mark[s.x][s.y][s.ty] = true;

    q.push(s);

    while(q.empty() == false)
    {
        s = q.front();
        q.pop();

        if(Map[s.x][s.y] == 'O' && s.ty == 4)
        {
            cout<<s.ans<<endl;
            return ;
        }

        if(s.ty == 0)
        {
            if(s.x-2 >= 1 && Map[s.x-2][s.y] != '#' && Map[s.x-2][s.y] != 'E' && mark[s.x-2][s.y][4] == false)
            {
                t.ty = 4;
                t.x = s.x-2;
                t.y = s.y;
                t.ans = s.ans + 1;

                mark[s.x-2][s.y][4] = true;

                q.push(t);
            }

            if(s.x+1 <= n && Map[s.x+1][s.y] != '#' && Map[s.x+1][s.y] != 'E' && mark[s.x+1][s.y][4] == false)
            {
                t.ty = 4;
                t.x = s.x+1;
                t.y = s.y;
                t.ans = s.ans+1;

                mark[s.x+1][s.y][4] = true;

                q.push(t);

            }

            if(s.y+1 <= m && s.x-1 >= 1 && Map[s.x][s.y+1] != '#' && Map[s.x-1][s.y+1] != '#' && mark[s.x][s.y+1][0] == false && mark[s.x-1][s.y+1][2] == false)
            {
                t.ty = 0;
                t.x = s.x;
                t.y = s.y+1;
                t.ans = s.ans+1;

                mark[s.x][s.y+1][0] = true ;
                mark[s.x-1][s.y+1][2] = true ;

                q.push(t);
            }

            if(s.y-1 >= 1 && s.x-1 >= 1 && Map[s.x][s.y-1] != '#' && Map[s.x-1][s.y-1] != '#' && mark[s.x][s.y-1][0] == false && mark[s.x-1][s.y-1][2] == false)
            {
                t.ty = 0;
                t.x = s.x;
                t.y = s.y-1;
                t.ans = s.ans+1;

                mark[s.x][s.y-1][0] = true ;
                mark[s.x-1][s.y-1][2] = true ;

                q.push(t);
            }
        }
        else if(s.ty == 1)
        {
            if(s.y-2 >= 1 && Map[s.x][s.y-2] != '#' && Map[s.x][s.y-2] != 'E' && mark[s.x][s.y-2][4] == false)
            {
                t.ty = 4;
                t.x = s.x;
                t.y = s.y-2;
                t.ans = s.ans + 1;

                mark[s.x][s.y-2][4] = true;

                q.push(t);
            }

            if(s.y+1 <= m && Map[s.x][s.y+1] != '#' && Map[s.x][s.y+1] != 'E' && mark[s.x][s.y+1][4] == false)
            {
                t.ty = 4;
                t.x = s.x;
                t.y = s.y+1;
                t.ans = s.ans+1;

                mark[s.x][s.y+1][4] = true;

                q.push(t);

            }

            if(s.y-1 >= 1 && s.x+1 <= n && Map[s.x+1][s.y] != '#' && Map[s.x+1][s.y-1] != '#' && mark[s.x+1][s.y][1] == false && mark[s.x+1][s.y-1][3] == false)
            {
                t.ty = 1;
                t.x = s.x+1;
                t.y = s.y;
                t.ans = s.ans+1;

                mark[s.x+1][s.y][1] = true ;
                mark[s.x+1][s.y-1][3] = true ;

                q.push(t);
            }

            if(s.y-1 >= 1 && s.x-1 >= 1 && Map[s.x-1][s.y] != '#' && Map[s.x-1][s.y-1] != '#' && mark[s.x-1][s.y][1] == false && mark[s.x-1][s.y-1][3] == false)
            {
                t.ty = 1;
                t.x = s.x-1;
                t.y = s.y;
                t.ans = s.ans+1;

                mark[s.x-1][s.y][1] = true ;
                mark[s.x-1][s.y-1][3] = true ;

                q.push(t);
            }
        }
        else if(s.ty == 2)
        {
            if(s.x-1 >= 1 && Map[s.x-1][s.y] != '#' && Map[s.x-1][s.y] != 'E' && mark[s.x-1][s.y][4] == false)
            {
                t.ty = 4;
                t.x = s.x-1;
                t.y = s.y;
                t.ans = s.ans + 1;

                mark[s.x-1][s.y][4] = true;

                q.push(t);
            }

            if(s.x+2 <= n && Map[s.x+2][s.y] != '#' && Map[s.x+2][s.y] != 'E' && mark[s.x+2][s.y][4] == false)
            {
                t.ty = 4;
                t.x = s.x+2;
                t.y = s.y;
                t.ans = s.ans+1;

                mark[s.x+2][s.y][4] = true;

                q.push(t);

            }

            if(s.y+1 <= m && s.x+1 <= n && Map[s.x][s.y+1] != '#' && Map[s.x+1][s.y+1] != '#' && mark[s.x][s.y+1][2] == false && mark[s.x+1][s.y+1][0] == false)
            {
                t.ty = 2;
                t.x = s.x;
                t.y = s.y+1;
                t.ans = s.ans+1;

                mark[s.x][s.y+1][2] = true ;
                mark[s.x+1][s.y+1][0] = true ;

                q.push(t);
            }

            if(s.y-1 >= 1 && s.x+1 <= n && Map[s.x][s.y-1] != '#' && Map[s.x+1][s.y-1] != '#' && mark[s.x][s.y-1][2] == false && mark[s.x+1][s.y-1][0] == false)
            {
                t.ty = 2;
                t.x = s.x;
                t.y = s.y-1;
                t.ans = s.ans+1;

                mark[s.x][s.y-1][2] = true ;
                mark[s.x+1][s.y-1][0] = true ;

                q.push(t);
            }
        }
        else if(s.ty == 3)
        {
            if(s.y-1 >= 1 && Map[s.x][s.y-1] != '#' && Map[s.x][s.y-1] != 'E' && mark[s.x][s.y-1][4] == false)
            {
                t.ty = 4;
                t.x = s.x;
                t.y = s.y-1;
                t.ans = s.ans + 1;

                mark[s.x][s.y-1][4] = true;

                q.push(t);
            }

            if(s.y+2 <= m && Map[s.x][s.y+2] != '#' && Map[s.x][s.y+2] != 'E' && mark[s.x][s.y+2][4] == false)
            {
                t.ty = 4;
                t.x = s.x;
                t.y = s.y+2;
                t.ans = s.ans+1;

                mark[s.x][s.y+2][4] = true;

                q.push(t);

            }

            if(s.y+1 <= m && s.x+1 <= n && Map[s.x+1][s.y] != '#' && Map[s.x+1][s.y+1] != '#' && mark[s.x+1][s.y][3] == false && mark[s.x+1][s.y+1][1] == false)
            {
                t.ty = 3;
                t.x = s.x+1;
                t.y = s.y;
                t.ans = s.ans+1;

                mark[s.x+1][s.y][3] = true ;
                mark[s.x+1][s.y+1][1] = true ;

                q.push(t);
            }

            if(s.y+1 <= m && s.x-1 >= 1 && Map[s.x-1][s.y] != '#' && Map[s.x-1][s.y+1] != '#' && mark[s.x-1][s.y][3] == false && mark[s.x-1][s.y+1][1] == false)
            {
                t.ty = 3;
                t.x = s.x-1;
                t.y = s.y;
                t.ans = s.ans+1;

                mark[s.x-1][s.y][3] = true ;
                mark[s.x-1][s.y+1][1] = true ;

                q.push(t);
            }
        }
        else if(s.ty == 4)
        {
            if(s.x-2 >= 1 && Map[s.x-1][s.y] != '#' && Map[s.x-2][s.y] != '#' && mark[s.x-1][s.y][0] == false && mark[s.x-2][s.y][2] == false)
            {
                t.ty = 0;
                t.x = s.x-1;
                t.y = s.y;
                t.ans = s.ans+1;

                mark[s.x-1][s.y][0] = true;
                mark[s.x-2][s.y][2] = true;

                q.push(t);
            }

            if(s.x+2 <= n && Map[s.x+1][s.y] != '#' && Map[s.x+2][s.y] != '#' && mark[s.x+1][s.y][2] == false && mark[s.x+2][s.y][0] == false)
            {
                t.ty = 2;
                t.x = s.x+1;
                t.y = s.y;
                t.ans = s.ans+1;

                mark[s.x+1][s.y][2] = true;
                mark[s.x+2][s.y][0] = true;

                q.push(t);
            }

            if(s.y-2 >= 1 && Map[s.x][s.y-1] != '#' && Map[s.x][s.y-2] != '#' && mark[s.x][s.y-1][1] == false && mark[s.x][s.y-2][3] == false)
            {
                t.ty = 1;
                t.x = s.x;
                t.y = s.y-1;
                t.ans = s.ans+1;

                mark[s.x][s.y-1][1] = true;
                mark[s.x][s.y-2][3] = true;

                q.push(t);
            }

            if(s.y+2 <= m && Map[s.x][s.y+1] != '#' && Map[s.x][s.y+2] != '#' && mark[s.x][s.y+1][3] == false && mark[s.x][s.y+2][1] == false)
            {
                t.ty = 3;
                t.x = s.x;
                t.y = s.y+1;
                t.ans = s.ans+1;

                mark[s.x][s.y+1][3] = true;
                mark[s.x][s.y+2][1] = true;

                q.push(t);
            }
        }
    }
    cout<<"Impossible"<<endl;
}

int main()
{
    int i,n,m;

    while(scanf("%d %d",&n,&m) && (n||m))
    {

        for(i = 1;i <= n; ++i)
        {
            scanf("%*c%s",Map[i]+1);
        }

        bfs(n,m);
    }
    return 0;
}


自在_飞花
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
POJ 3322 Bloxorz I(BFS:求迷宫最短路径)
code
05-14 2000
POJ 3322 Bloxorz I(BFS:求迷宫最短路径) http://poj.org/problem?id=3322 题意:有一个R*C的网格,网格中有3种格子:正常格子,脆弱格子以及空格子.现在给你一个1*2立方体的初始位置,要你求出将该立方体移动到终点所需要的最小步数. 分析:其实和一般的BFS求最短路径没本质区别,就是状态设计和移动可能复杂点.        我们令1
【POJ3322】Bloxorz I
weixin_30672019的博客
04-14 111
一道非常棒的搜索题，做完之后感觉神清气爽…… 可以肯定的是，本题属于走地图一类的搜索题，适合用bfs求解，然而本题细节极多，有很多需要注意的地方。 我们定义状态三元组(x,y,z)表示当前移动到位置(x,y)，且朝向z（我们不妨假定z=0意味着长方体立在地面上，z=1 意味着长方体横躺，x,y表示左边长方体的位置；z=2意味着长方体竖躺，x,y表示上边长方体的位置）。同时，我们读入之后处理起点...
POJ 3322 BFS
neweryyy的博客
12-09 126
题意 传送门 POJ 3322 Bloxorz I 题解 长方体当前的状态为其横、纵坐标与摆放状态组成的三元组，为了方便表示，只取长方体左上方的位置作为横、纵坐标状态，BFSBFSBFS 求解即可。 #include <algorithm> #include <cstdio> #include <cstring> #include <queue> using namespace std; #define maxn 505 struct node { i
POJ3322bloxorz
zhagoodwell查的博客
05-10 1073
这道题目很适合学习广度优先搜搜的小盆友： Bloxorz是一个风靡世界的小游戏。Bloxorz的地图是一个N行M列的矩阵，每个位置可能是硬地（用.表示）、易碎地面（用E表示）、禁地（用#表示）、起点（用X表示）或终点（用O表示）。你的任务是操作一个1*1*2的长方体。这个长方体在地面上有两种放置形式，“立”在地面上（1*1的面接触地面）或者“躺”在地面上（1*2的面接触地面）。在每一步操作中，可以按上下左右四个键之一。按下之后，长方体向对应的方向沿着棱滚动90度。任意时刻，长方体不能有任何部位接触禁.
POJ3322（bfs+细节处理)
weixin_30855761的博客
08-19 175
先骂一句傻逼评测机 T了一下午 去入门OJ交终于A掉了 800+ms，对于2000ms的时限我怎么都想不通POJ怎么会T掉 就是一个傻逼bfs，注意横着和竖着的情况，处理比较麻烦的是对于两个点（ax,ay）和(bx,by),如何打标记 我原来的思路就是开一个结构体root，然后map映射过去，后来发现被T的死死的，手造大样例跑了2.5s。又想到另一个基于hash映射的写法，把4个数看成500进制数...
POJ3322.rar_poj33_www.3322.se.c
最新发布
09-19
"POJ3322说明.txt"可能包含了问题的具体描述、输入输出格式、样例测试用例等信息，这对于理解问题和编写解决方案至关重要。 在"POJ3322_Code.cpp"这个文件中，很可能包含了实现上述宽搜算法的C++代码。通过阅读和...
NOI2002.rar_NOI 2002 dragon_poj bfs
09-14
标题中的“NOI2002.rar_NOI 2002 dragon_poj bfs”提到了几个关键元素：NOI（全国青少年信息学奥林匹克），2002年赛事，dragon问题，以及poj_bfs。这表明我们即将讨论的是2002年全国青少年信息学奥林匹克竞赛中的...
POJ3026-Borg Maze【BFS+Prim】
07-30
《POJ3026-Borg Maze：BFS与Prim算法的应用解析》 在计算机科学领域，图论是解决问题的重要工具之一，而BFS（广度优先搜索）和Prim算法则是其中的两种经典算法。本篇文章将围绕北大POJ3026题目“Borg Maze”来探讨...
POJ1426-Find The Multiple【BFS+同余模】
07-31
【标题】"POJ1426-Find The Multiple【BFS+同余模】"是一道来源于北京大学在线编程平台POJ的算法题目，主要涉及到了广度优先搜索（BFS）与同余模运算的知识点。这道题目要求解决的是寻找一个整数的倍数问题，可能...
POJ1005-I Think I Need a Houseboat
07-29
【标题】"POJ1005-I Think I Need a Houseboat" 是一个编程竞赛题目，源自北京大学的在线评测系统POJ（Problem Set of Peking University）。这个题目旨在考验参赛者的算法设计和实现能力，主要涉及数据结构和动态...
Bloxorz I [POJ3322]
lb2003
04-16 317
题面描述 一个游戏，为一个NNN行MMM列第二矩阵，位置可能是硬地("...")、易碎地面(“EEE”)、禁地("#")、起点（“OOO”)或终点(“EEE”)
POJ3322滚箱子游戏（不错）
天使也掉毛
01-31 1606
题意：       讲的是一个游戏，就是在一个平面上滚动一个1*1*2的长方体的游戏，在本题里面的游戏规则是这样的： （1）      一开始给你箱子的状态，可能是横着也可能是竖着。 （2）      每一次可以滚动箱子，但是每次滚动到的位置（1个或者2个）都必须不能是空的。 （3）      有的位置只能经得起箱子一半的重量，有的能经得起真个箱子的重量，经得起一半的格子意思就是不能
POJ 3322 Bloxorz I
AcerMoOi之路
04-08 353
"首先呢 这个题目的名字好啊 ORZ啊 ",SiriusRen学长如是说原游戏地址 http://www.albinoblacksheep.com/games/bloxorz 这个题我OLE完MLE，之后TLE，再无限TLE，然后CE，然后WA，最后AC了，压线，2000msQAQ爆搜玩完游戏应该可以看出，方块有三种躺法firstsecondthird所以我们爆搜是，要处理三种情况下坐标的变化，用...
poj3322翻译
ysmor的博客
06-05 790
poj3322翻译，系列1，系列2poj3323马上出品
poj3322——Bloxorz I//bfs
r_ax的专栏
06-24 1009
广搜，关键在于状态转移及状态的记录。 很囧的是，代码太死长了 而且，效率也不行...#include#include#includeusing namespace std;#define maxn 505char g[maxn][maxn];int R,C;int dir[][2]={{1,0},{0,1},{0,-1},{-1,0}};int vis[ma
Bloxorz I POJ - 3322(广度优先搜索)
肘子的博客
08-11 232
题意：传送门 对应游戏：传送门 题解：对于这个木块，可以发现有三个状态，第一个状态是直立的，第二个状态是横躺着，第三个状态是竖躺着，那么状态维护三个值x,y,liex,y,liex,y,lie，分别对应位置以及状态，最后在维护dist[x][y][lie]dist[x][y][lie]dist[x][y][lie]表示到达这个位置且是lielielie这种状态的最小步数，维护好各种边界条件即可。 ...
POJ3322 Bloxorz I(BFS)
ACMer_quack&cheer
03-28 612
很有意思的一个益智小游戏。题目我就不描述了，玩过的人都知道规则。 题目传送门：http://poj.org/problem?id=3322 空格子不能走(可以看成墙)，标号为E表示脆弱的格子，箱子在上面不能竖放，只能横放。终点只能竖着放进去。 很明显是搜索题，状态表示也不用太费力去想。需要保存箱子一个角的位置，和摆放的状态f；如果箱子竖放，则位置就是它本身的位置，f=0;如果左右横放，则保存左
2010FZUACM_高级数据结构习题讲解1
08-04
"这篇资料是关于高级数据结构的习题讲解，主要涉及树状数组的应用和解题策略，包括一维、二维甚至三维树状数组的使用，以及在实际问题中的应用实例。" 在这次的高级数据结构习题讲解中，主要探讨了如何利用树状数组...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值