POJ 3322 Bloxorz I

最新推荐文章于 2022-11-03 21:06:09 发布
最新推荐文章于 2022-11-03 21:06:09 发布
阅读量443 收藏
点赞数
分类专栏： 搜索 文章标签： poj 搜索 bfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31785871/article/details/51582478
版权

首先呢 这个题目的名字好啊 ORZ啊
这里写图片描述
如果看不懂题意的话 请戳这里 玩儿几盘就懂了【微笑】
http://www.albinoblacksheep.com/games/bloxorz
这里写图片描述
就是这个神奇的木块可以各种滚
但是有墙的地方是不能去的 有的地方只能躺着走 立着会掉下去。（姑且把这种底面叫“软底面”吧） （很坑的）
思路：
搜索（BFS）
一开始是想传5个参数（其实没必要 。。。）
① flag flag表示在第几种状态② x1 ③ y1 ④ x2 ⑤ y2（坐标们）
1. flag=0
代表这个木块是立着的 这个时候只有x1,y1有用
2. flag=1
代表木块的位置如下图（呃你愿意叫它竖着躺着也好）
这里写图片描述
这个时候y1,y2相同 x1,x2相差1
3. flag=2
代表木块的位置如下图（呃你愿意叫它横着躺着也好）
这里写图片描述
这个时候x1,x2相同 y1,y2相差1
每次搜索的时候判一下符不符合
① 不轧墙
② 没有在“软地面”上立着

省略无数次脑残错误。 。。
终于AC 了
以下是我的第一个AC代码

//By: Sirius_Ren
#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
char a[705][705];
char xxs[4][3]={{1,2,1},{0,0,2},{0,0,2},{-2,-1,1}},yys[4][2]={{0,0},{1,2},{-2,-1},{0,0}};
char xx1[4][3]={{-1,0,0},{2,0,0},{0,1,1},{0,1,1}},yy1[4][2]={{0,0},{0,0},{1,1},{-1,-1}};
char xx2[4][3]={{-1,-1,2},{1,1,2},{0,0,0},{0,0,0}},yy2[4][2]={{0,1},{0,1},{-1,0},{2,0}};
int vis[705][705][3];
int n,m,ex,ey;
struct node
{
    short flag;
    int x1,y1,x2,y2;
}J,U;
queue<node> q;
int main()
{
    while(scanf("%d%d",&n,&m)&&(n||m))
    {
        J.flag=1;J.x1=J.x2=J.y1=J.y2=0;
        memset(vis,-1,sizeof(vis));
        for(int i=1;i<=n;i++)
            for(int j=01;j<=m;j++)
            {
                cin>>a[i][j];
                if(a[i][j]=='X')
                {
                    if(J.flag) J.x1=i,J.y1=j,J.flag=!J.flag;
                    else       J.x2=i,J.y2=j,J.flag=!J.flag;
                }
                else if(a[i][j]=='O')ex=i,ey=j;
            }
//      printf("%d  %d",ex,ey);
        if(J.x1==J.x2)J.flag=2;
        vis[J.x1][J.y1][J.flag]=0;
        q.push(J);
        while(!q.empty())
        {
            J=q.front();q.pop();
//          printf("J=%d flag=%d x1=%d y1=%d x2=%d y2=%d\n",vis[J.x1][J.y1][J.flag],J.flag,J.x1,J.y1,J.x2,J.y2);
            if(J.x1==ex&&J.y1==ey&&!J.flag)break;
            if(!J.flag)
            {
                for(int i=0;i<4;i++)
                {
                    int F=0;
                    for(int j=0;j<=1;j++)
                    {
                        if(a[J.x1+xxs[i][j]][J.y1+yys[i][j]]=='#')F=1;
                    }
                    U.flag=xxs[i][2],U.x1=J.x1+xxs[i][0],U.x2=J.x1+xxs[i][1],U.y1=J.y1+yys[i][0],U.y2=J.y1+yys[i][1];
                    if(F||~vis[U.x1][U.y1][U.flag])continue;
                    vis[U.x1][U.y1][U.flag]=vis[J.x1][J.y1][J.flag]+1;
    //              printf("U=%d %d  %d  %d  %d  %d\n",i,U.flag,U.x1,U.y1,U.x2,U.y2);
                    q.push(U);
                }
            }
            else if(J.flag==1)
            {
                for(int i=0;i<4;i++)
                {
                    int F=0;
                    for(int j=0;j<=1;j++)
                    {
                        if(a[J.x1+xx1[i][j]][J.y1+yy1[i][j]]=='#')F=1;
                    }
                    U.flag=xx1[i][2],U.x1=J.x1+xx1[i][0],U.x2=J.x1+xx1[i][1],U.y1=J.y1+yy1[i][0],U.y2=J.y1+yy1[i][1];
                    if(F||~vis[U.x1][U.y1][U.flag]||(!U.flag&&a[U.x1][U.y1]=='E'))continue;
                    vis[U.x1][U.y1][U.flag]=vis[J.x1][J.y1][J.flag]+1;
    //              printf("U=%d %d  %d  %d  %d  %d\n",i,U.flag,U.x1,U.y1,U.x2,U.y2);
                    q.push(U);
                }
            }
            else if(J.flag==2)
            {
                for(int i=0;i<4;i++)
                {
                    int F=0;
                    for(int j=0;j<=1;j++)
                    {
                        if(a[J.x1+xx2[i][j]][J.y1+yy2[i][j]]=='#')F=1;
                    }
                    U.flag=xx2[i][2],U.x1=J.x1+xx2[i][0],U.x2=J.x1+xx2[i][1],U.y1=J.y1+yy2[i][0],U.y2=J.y1+yy2[i][1];
                    if(F||~vis[U.x1][U.y1][U.flag]||(!U.flag&&a[U.x1][U.y1]=='E'))continue;
                    vis[U.x1][U.y1][U.flag]=vis[J.x1][J.y1][J.flag]+1;
    //              printf("U=%d %d  %d  %d  %d  %d\n",i,U.flag,U.x1,U.y1,U.x2,U.y2);
    //              printf("%d  %d \n",vis[U.x1][U.y1][U.flag],vis[J.x1][J.y1][J.flag]);
                    q.push(U);
                }
            }
        }
        if(~vis[ex][ey][0])printf("%d\n",vis[ex][ey][0]);
        else printf("Impossible\n");
        while(!q.empty())q.pop();
    }
}
/*
7 7
#######
#..X###
#..X#O#
#....E#
#....E#
#.....#
#######
8 17
#################
#######.......###
#....##...##..###
#.........##....#
#.X..#######..O.#
#....#######....#
#############...#
#################
7 7
#######
#..X###
#..##O#
#....E#
#....E#
#.....#
#######
0 0
*/

这时候 我发现了一个问题: 如果每回指定flag为一个值的时候木块的方向，就可以在结构体里面只传3个参数了，随后我就试了试。
的确是这样

//By: Sirius_Ren
#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
char a[705][705];
char xxs[4][3]={{1,2,1},{0,0,2},{0,0,2},{-2,-1,1}},yys[4][2]={{0,0},{1,2},{-2,-1},{0,0}};
char xx1[4][3]={{-1,0,0},{2,0,0},{0,1,1},{0,1,1}},yy1[4][2]={{0,0},{0,0},{1,1},{-1,-1}};
char xx2[4][3]={{-1,-1,2},{1,1,2},{0,0,0},{0,0,0}},yy2[4][2]={{0,1},{0,1},{-1,0},{2,0}};
int vis[705][705][3];
int n,m,ex,ey,x2,y2;
struct node
{
    short flag;
    int x1,y1;
}J,U;
queue<node> q;
int main()
{
    while(scanf("%d%d",&n,&m)&&(n||m))
    {
        J.flag=1;J.x1=J.y1=x2=y2=0;
        memset(vis,-1,sizeof(vis));
        for(int i=1;i<=n;i++)
            for(int j=01;j<=m;j++)
            {
                cin>>a[i][j];
                if(a[i][j]=='X')
                {
                    if(J.flag) J.x1=i,J.y1=j,J.flag=!J.flag;
                    else       x2=i,y2=j,J.flag=!J.flag;
                }
                else if(a[i][j]=='O')ex=i,ey=j;
            }
        if(J.x1==x2)J.flag=2;
        vis[J.x1][J.y1][J.flag]=0;
        q.push(J);
        while(!q.empty())
        {
            J=q.front();q.pop();
            if(J.x1==ex&&J.y1==ey&&!J.flag)break;
            if(!J.flag)
            {
                for(int i=0;i<4;i++)
                {
                    int F=0;
                    for(int j=0;j<=1;j++)
                    {
                        if(a[J.x1+xxs[i][j]][J.y1+yys[i][j]]=='#')F=1;
                    }
                    U.flag=xxs[i][2],U.x1=J.x1+xxs[i][0],U.y1=J.y1+yys[i][0];
                    if(F||~vis[U.x1][U.y1][U.flag])continue;
                    vis[U.x1][U.y1][U.flag]=vis[J.x1][J.y1][J.flag]+1;
                    q.push(U);
                }
            }
            else if(J.flag==1)
            {
                for(int i=0;i<4;i++)
                {
                    int F=0;
                    for(int j=0;j<=1;j++)
                    {
                        if(a[J.x1+xx1[i][j]][J.y1+yy1[i][j]]=='#')F=1;
                    }
                    U.flag=xx1[i][2],U.x1=J.x1+xx1[i][0],U.y1=J.y1+yy1[i][0];
                    if(F||~vis[U.x1][U.y1][U.flag]||(!U.flag&&a[U.x1][U.y1]=='E'))continue;
                    vis[U.x1][U.y1][U.flag]=vis[J.x1][J.y1][J.flag]+1;
                    q.push(U);
                }
            }
            else if(J.flag==2)
            {
                for(int i=0;i<4;i++)
                {
                    int F=0;
                    for(int j=0;j<=1;j++)
                    {
                        if(a[J.x1+xx2[i][j]][J.y1+yy2[i][j]]=='#')F=1;
                    }
                    U.flag=xx2[i][2],U.x1=J.x1+xx2[i][0],U.y1=J.y1+yy2[i][0];
                    if(F||~vis[U.x1][U.y1][U.flag]||(!U.flag&&a[U.x1][U.y1]=='E'))continue;
                    vis[U.x1][U.y1][U.flag]=vis[J.x1][J.y1][J.flag]+1;
                    q.push(U);
                }
            }
        }
        if(~vis[ex][ey][0])printf("%d\n",vis[ex][ey][0]);
        else printf("Impossible\n");
        while(!q.empty())q.pop();
    }
}

继续发掘缩短代码的潜能。。。。
我们发现：无论flag等于多少，之后所进行的操作有一定的相似性。我们就可以把它写成一个函数，每次只需把要进行操作的数组传进去就OK了。

//By: Sirius_Ren
#include <queue>
#include <cstdio>
#include <cstring>
using namespace std;
char xxs[4][3]={{1,2,1},{0,0,2},{0,0,2},{-2,-1,1}},yys[4][2]={{0,0},{1,2},{-2,-1},{0,0}},a[705][705];
char xx1[4][3]={{-1,0,0},{2,0,0},{0,1,1},{0,1,1}},yy1[4][2]={{0,0},{0,0},{1,1},{-1,-1}};
char xx2[4][3]={{-1,-1,2},{1,1,2},{0,0,0},{0,0,0}},yy2[4][2]={{0,1},{0,1},{-1,0},{2,0}};
int vis[705][705][3];
int n,m,ex,ey,x2,y2;
struct node{short flag;int x1,y1;}J,U;
queue<node> q;
inline void f(char xxx[4][3],char yyy[4][2]){
    for(int i=0;i<4;i++){
        int F=0;
        for(int j=0;j<=1;j++)if(a[J.x1+xxx[i][j]][J.y1+yyy[i][j]]=='#')F=1;
        U.flag=xxx[i][2],U.x1=J.x1+xxx[i][0],U.y1=J.y1+yyy[i][0];
        if(F||~vis[U.x1][U.y1][U.flag]||(!U.flag&&a[U.x1][U.y1]=='E'))continue;
        vis[U.x1][U.y1][U.flag]=vis[J.x1][J.y1][J.flag]+1;
        q.push(U);
    }
}
int main()
{
    while(scanf("%d%d",&n,&m)&&(n||m)){
        J.flag=1;J.x1=J.y1=x2=y2=0;
        memset(vis,-1,sizeof(vis));
        for(int i=1;i<=n;i++)
            for(int j=0;j<=m;j++){
                scanf("%c",&a[i][j]);
                if(a[i][j]=='X')
                    if(J.flag) J.x1=i,J.y1=j,J.flag=!J.flag;
                    else x2=i,y2=j,J.flag=!J.flag;
                else if(a[i][j]=='O')ex=i,ey=j;
            }
        if(J.x1==x2)J.flag=2;
        vis[J.x1][J.y1][J.flag]=0;
        q.push(J);
        while(!q.empty()){
            J=q.front();q.pop();
            if(J.x1==ex&&J.y1==ey&&!J.flag)break;
            if(!J.flag) f(xxs,yys);
            else if(J.flag==1) f(xx1,yy1);
            else f(xx2,yy2);
        }
        if(~vis[ex][ey][0])printf("%d\n",vis[ex][ey][0]);
        else printf("Impossible\n");
        while(!q.empty())q.pop();
    }
}

这里写图片描述

缩完代码就是爽啊
这里写图片描述

但是程序好慢。。
找了一下原因
这里写图片描述

这里写图片描述

All in all,STL不是万能的。 它会影响到程序的运行速度。

Sirius_Ren
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
POJ3322.rar_poj33_www.3322.se.c
09-19
"POJ3322说明.txt"可能包含了问题的具体描述、输入输出格式、样例测试用例等信息，这对于理解问题和编写解决方案至关重要。 在"POJ3322_Code.cpp"这个文件中，很可能包含了实现上述宽搜算法的C++代码。通过阅读和...
poj.rar_poj
09-23
标题中的"poj.rar_poj"暗示了这是一个与POJ（Programming Online Judge）相关的压缩文件，POJ是一个在线编程竞赛平台，主要供程序员们练习和提交算法解决方案。在这个压缩包中，很可能包含了用户在POJ上参与编程挑战...
POJ3322 Bloxorz I
最新发布
m0_73035684的博客
11-03 70
然后就是进入了重头戏，广搜的函数，我们还是遍历4个方向，然后3种形态4个方向，那么就是12对增量数组，也很好写，比如说，现在的形态是0，那么向上倒，x的增量是-2，y的增量是0，这个很好写，然后我们得到当前形态当前方向下的立方体的坐标，还有就是得到它现在的形态，这个分类讨论就行了，如果原来是0，那么向上就变成2，向右就变成了1，这个也很好想，然后就是分类讨论，三种形态，有越界或者不符合题意的情况就跳过，最后就是简单的判断，入队就行了，
poj3322 Bloxorz I
YHaX的博客
07-30 475
bfs暴搜
POJ3322Bloxorz I
weixin_34082695的博客
02-15 62
POJ3322Bloxorz I 暴搜，next数组与处理一下（小技巧） 1 #include <cstdio> 2 #include <iostream> 3 #include <cstring> 4 #include <cmath> 5 #include <queue> 6 #incl...
POJ3322 Bloxorz I BFS
Kevin的博客
09-10 131
题目链接 http://poj.org/problem?id=3322 分析 每次操作，地图不会改变，变化的坐标及放置方式可以设为状态，进行BFS。 预处理出各种放置方式下，向各个方向移动后状态的变化情况。 AC代码 #include <cstdio> #include <cstring> #include <queue> using namespace st...
POJ3322bloxorz
zhagoodwell查的博客
05-10 1085
这道题目很适合学习广度优先搜搜的小盆友： Bloxorz是一个风靡世界的小游戏。Bloxorz的地图是一个N行M列的矩阵，每个位置可能是硬地（用.表示）、易碎地面（用E表示）、禁地（用#表示）、起点（用X表示）或终点（用O表示）。你的任务是操作一个1*1*2的长方体。这个长方体在地面上有两种放置形式，“立”在地面上（1*1的面接触地面）或者“躺”在地面上（1*2的面接触地面）。在每一步操作中，可以按上下左右四个键之一。按下之后，长方体向对应的方向沿着棱滚动90度。任意时刻，长方体不能有任何部位接触禁.
BFS POJ3322 Bloxorz I
weixin_30920513的博客
08-19 55
Bloxorz I Time Limit: 2000MS Memory Limit: 65536K Total Submissions: 6108 Accepted: 2007 Description Little Tom loves playing games. One day he downloads a little com...
POJ.rar_poj
09-19
【标题】"POJ.rar_poj" 指的是一份与编程竞赛相关的压缩文件，主要涉及POJ（Problem Overloading Judge）平台上的问题解答。POJ是一个在线的编程竞赛平台，它为参赛者提供了大量的算法题目进行练习和比赛，以提升...
POJ 1945 暴搜+打表 （Or 暴搜+判重）
SiriusRen的博客
08-25 3586
思路： 呃呃 暴搜+打表 暴搜的程序：：稳稳的TLE+MLE （但是我们可以用来打表） 然后我们就可以打表过了 hiahiahia 可以证明最小的那个数不会超过200（怎么证明的我也不知道），然后就直接判重就好了 打表： 打表的程序： // by SiriusRen #include <queue> #include <cstdio> #include <algorithm> using
POJ 1010 题目翻译+题解
SiriusRen的博客
03-19 2900
POJ 1010 题目翻译+题解 。STAMPS Description Have you done any Philately lately? 你最近有没有集邮？You have been hired by the Ruritanian Postal Service (RPS) to design their new postage software. The software allo
POJ 3188暴搜
SiriusRen的博客
08-27 1021
题意： 思路： 裸的暴搜 …….但是要注意如果你不用所有的按键就能输出最优解的话一定要把所有的子木都安排到一个位置…. 我的一群PE就是这么来的……为什么写的人这么少…… // by SiriusRen #include <cstdio> #include <cstring> #include <algorithm> using namespace std; int b,l,d,
POJ 1111（数字很吉利嘛） 简单BFS
SiriusRen的博客
03-20 991
POJ 1111 easy BFS Image Perimeters Time Limit: 1000MS Memory Limit: 10000K Total Submissions: 8594 Accepted: 5145
POJ 2458 DFS+判重
SiriusRen的博客
10-29 768
题意： 思路： 搜+判重 嗯搞定 （听说有好多人用7个for写得….）//By SiriusRen #include <bitset> #include <cstdio>0 using namespace std; bitset<134217728>bit; char s[17][17],vis[17][17],xx[]={1,-1,0,0},yy[]={0,0,1,-1}; i
POJ 1386 判断欧拉回路
SiriusRen的博客
07-12 755
题意：要开启一扇门，n个单词是密码，n个单词中，如果一个单词的首字母和前一个单词的尾字母相同，并且每个单词都能这么连起来且只用一次，则门可以开启，否则不能开启，现给出单词，判断门是否可以开。有向图欧拉通路充要条件：D为有向图，D的基图连通，并且所有顶点的出度与入度都相等；或者除两个顶点外，其余顶点的出度与入度都相等，而这两个顶点中一个顶点的出度与入度之差为1，另一个顶点的出度与入度之差为-1。 有
POJ 3635 优先队列BFS
SiriusRen的博客
06-06 716
（感谢lyd学长的幻灯片） 注意vis数组的应用 在vis[i][j]中 i表示到了第i个点 j表示还剩j升油 vis[i][j]表示最小话费。 这样只需搜到话费比它少的更新入堆就OK了//By: Sirius_Ren #include <queue> #include <cstdio> #include <cstring> using namespace std; struct
POJ 3271 BFS （大坑）
SiriusRen的博客
10-14 678
被某人拉进了坑 完完全全被坑一天的题…… 题意： 正解思路： 先把每一个点搜一遍 预处理出它能在一步之内到的所有点 并连边 然后用一个类似DP的东西把方案数加起来就搞定了 （其实 也不是很难）但是 我为什么会挂呢 首先 我想偷个懒，想少写一个BFS 就直接按照原来的边搜过去了 当然错了 查了一上午 （对着数据查 小数据竟然全水过去了！！！）下午颓了会儿
POJ 3764 DFS+trie树
SiriusRen的博客
07-17 664
题意： 给你一棵树，求树中最长的xor路径。（n<=100000） 思路： 首先我们知道 A xor B =(A xor C) xor (B xor C) 我们可以随便选一个点DFS 顺便做出与这个点连接的其它点的xor长度 但是 枚举起点&重点+判断会TLE 所以呢 随后 就是重头戏了：trie树 这是一棵神奇的树 （莫名想到了“这是一个神奇的网站”）我们可以从高
POJ编程题解资源集合
"这些题目是来自POJ (Programming Online Judge) 的一系列算法练习题，涵盖了基础到中等难度的编程问题。题目涉及了各种算法和数据结构，包括但不限于数学计算、字符串处理、逻辑推理、递归、动态规划、位运算等。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值