poj 3322 Bloxorz I （bfs+辅助数组减代码量）

最新推荐文章于 2019-09-24 17:35:42 发布
最新推荐文章于 2019-09-24 17:35:42 发布
阅读量126 收藏
点赞数
本文介绍了一款方块游戏的实现方法，重点讲解了如何使用三维数组进行状态记录及辅助数组来简化移动操作，同时提供了两种不同版本的C++代码实现：单一搜索和双向搜索算法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

很好玩的一个游戏，建议大家做完了去玩一玩~。

方块的状态有3种情况，竖着，横躺着，竖躺着，所以可以用一个标记变量表示。

对于判重，可以开一个三维的数组来判断。

麻烦的地方在于移动，如果直接模拟的话，将会产生很大的代码量。250~300行左右……

可以开几个辅助数组，直接判断上下左右时相应的坐标变化。

写辅助数组时最好头脑清醒，写错了某个的话，debug都很困难。。。（可以注意上下的对称性）

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
using namespace std;
char map[505][505];
int endx,endy;
struct node
{
   int dis;
   int flag;        //0=竖着,1=横躺着,2=竖躺着
   int x1;
   int y1;
   int x2;
   int y2;
}start;
node q[1000000];
bool vis[505][505][3];
int dx1[3][4]={{-2,1,0,0},{-1,1,0,0},{-1,2,0,0}};
int dy1[3][4]={{0,0,-2,1},{0,0,-1,2},{0,0,-1,1}};
int ddx[4]={-1,1,0,0};
int ddy[4]={0,0,-1,1};
int dx2[3][4]={{-1,2,0,0},{-1,1,0,0},{-2,1,0,0}};
int dy2[3][4]={{0,0,-1,2},{0,0,-2,1},{0,0,-1,1}};
int c[3][4]={{2,2,1,1},{1,1,0,0},{0,0,2,2}};
int n,m;
bool f(int x,int y)
{
    return x>=0&&x<n&&y>=0&&y<m;
}
bool isok(node &t)
{
    if(!f(t.x1,t.y1)||!f(t.x2,t.y2)) return false;
    if(t.flag==0&&map[t.x1][t.y1]=='E') return false;
    if(map[t.x1][t.y1]=='#'||map[t.x2][t.y2]=='#') return false;
    return true;
}

void creat()
{
   for(int i=0;i<n;i++)
   for(int j=0;j<m;j++)
   {
       if(map[i][j]=='O')
       {
           endx=i;endy=j;
       }
       else if(map[i][j]=='X')
       {
           start.x2=start.x1=i;start.y2=start.y1=j;
           int rx=i+ddx[3],ry=j+ddy[3];
           int dx=i+ddx[1],dy=j+ddy[1];
           if(f(rx,ry)&&map[rx][ry]=='X')
           {
               start.flag=1;
               start.x2=rx;start.y2=ry;
               map[i][j]=map[rx][ry]='.';
           }
           else if(f(dx,dy)&&map[dx][dy]=='X')
           {
               start.flag=2;
               start.x2=dx;start.y2=dy;
               map[i][j]=map[dx][dy]='.';
           }
           else
           {
               start.flag=0;
               map[i][j]='.';
           }
       }
   }
   start.dis=0;
}
bool expend(node &t,int d)
{
    t.x1+=dx1[t.flag][d];
    t.y1+=dy1[t.flag][d];
    t.x2+=dx2[t.flag][d];
    t.y2+=dy2[t.flag][d];
    t.dis++;
    t.flag=c[t.flag][d];
    if(!isok(t)) return false;
    if(!vis[t.x1][t.y1][t.flag])
    {

        vis[t.x1][t.y1][t.flag]=1;
        return true;
    }
    return false;
}
void bfs()
{
    int rear=0,front=0;
    q[rear++]=start;
    node f,r;
    while(front<rear)
    {
        f=q[front];
        for(int d=0;d<4;d++)
        {
            r=f;
            if(expend(r,d))
            {
                q[rear++]=r;
                if(r.x1==endx&&r.y1==endy&&r.flag==0)
                {
                    printf("%d\n",r.dis);
                    return;
                }
            }
        }
        front++;
    }
    printf("Impossible\n");
}
int main()
{

    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(!n&&!m) break;
        for(int i=0;i<n;i++)
        {
            scanf("%s",map[i]);
        }
        memset(vis,0,sizeof(vis));
        creat();
        bfs();
    }
    return 0;
}


900多ms很不满意，直接把原代码改成了双搜，竟然还是800多ms。。。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
using namespace std;
char map[505][505];
int endx,endy;
struct node
{
   int dis;
   int flag;        //0=竖着,1=横躺着,2=竖躺着
   int x1;
   int y1;
   int x2;
   int y2;
}start,end;
node q1[1000000];
node q2[1000000];
int vis[505][505][3];
int vis2[505][505][3];
int dx1[3][4]={{-2,1,0,0},{-1,1,0,0},{-1,2,0,0}};
int dy1[3][4]={{0,0,-2,1},{0,0,-1,2},{0,0,-1,1}};
int ddx[4]={-1,1,0,0};
int ddy[4]={0,0,-1,1};
int dx2[3][4]={{-1,2,0,0},{-1,1,0,0},{-2,1,0,0}};
int dy2[3][4]={{0,0,-1,2},{0,0,-2,1},{0,0,-1,1}};
int c[3][4]={{2,2,1,1},{1,1,0,0},{0,0,2,2}};
int n,m;
bool f(int x,int y)
{
    return x>=0&&x<n&&y>=0&&y<m;
}
bool isok(node &t)
{
    if(!f(t.x1,t.y1)||!f(t.x2,t.y2)) return false;
    if(t.flag==0&&map[t.x1][t.y1]=='E') return false;
    if(map[t.x1][t.y1]=='#'||map[t.x2][t.y2]=='#') return false;
    return true;
}

void creat()
{
   for(int i=0;i<n;i++)
   for(int j=0;j<m;j++)
   {
       if(map[i][j]=='O')
       {
           endx=i;endy=j;
           end.x1=end.x2=i;
           end.y1=end.y2=j;
           end.flag=0;
           end.dis=0;
       }
       else if(map[i][j]=='X')
       {
           start.x2=start.x1=i;start.y2=start.y1=j;
           int rx=i+ddx[3],ry=j+ddy[3];
           int dx=i+ddx[1],dy=j+ddy[1];
           if(f(rx,ry)&&map[rx][ry]=='X')
           {
               start.flag=1;
               start.x2=rx;start.y2=ry;
               map[i][j]=map[rx][ry]='.';
           }
           else if(f(dx,dy)&&map[dx][dy]=='X')
           {
               start.flag=2;
               start.x2=dx;start.y2=dy;
               map[i][j]=map[dx][dy]='.';
           }
           else
           {
               start.flag=0;
               map[i][j]='.';
           }
       }
   }
   start.dis=0;
}
bool expend(node &t,int d)
{
    t.x1+=dx1[t.flag][d];
    t.y1+=dy1[t.flag][d];
    t.x2+=dx2[t.flag][d];
    t.y2+=dy2[t.flag][d];
    t.dis++;
    t.flag=c[t.flag][d];
    if(!isok(t)) return false;
    return true;
}
void bfs()
{
    int rear1=0,front1=0;
    q1[rear1++]=start;
    int rear2=0,front2=0;
    q2[rear2++]=end;
    node f1,r1,f2,r2;
    int k1=1,kk1=0,k2=1,kk2=0;
    while(front1<rear1&&front2<rear2)
    {
        while(k1--){
        f1=q1[front1];front1++;
        for(int d=0;d<4;d++)
        {
            r1=f1;
            if(expend(r1,d))
            {
                if(vis2[r1.x1][r1.y1][r1.flag])
                {
                    if(vis2[r1.x1][r1.y1][r1.flag]==-1)
                    vis2[r1.x1][r1.y1][r1.flag]=0;
                    printf("%d\n",r1.dis+vis2[r1.x1][r1.y1][r1.flag]);
                    return;
                }
                if(!vis[r1.x1][r1.y1][r1.flag])
                {
                    vis[r1.x1][r1.y1][r1.flag]=r1.dis;
                    q1[rear1++]=r1;
                    kk1++;
                }
            }
        }
        }
        k1=kk1;kk1=0;
        while(k2--)
        {
            f2=q2[front2];front2++;
        for(int d=0;d<4;d++)
        {
            r2=f2;
            if(expend(r2,d))
            {
                if(vis[r2.x1][r2.y1][r2.flag])
                {
                    if(vis[r2.x1][r2.y1][r2.flag]==-1)
                    vis[r2.x1][r2.y1][r2.flag]=0;
                    printf("%d\n",r2.dis+vis[r2.x1][r2.y1][r2.flag]);
                    return;
                }
                if(!vis2[r2.x1][r2.y1][r2.flag])
                {
                    vis2[r2.x1][r2.y1][r2.flag]=r2.dis;
                    q2[rear2++]=r2;
                    kk2++;
                }
            }
        }
        }
        k2=kk2;
        kk2=0;
    }
    printf("Impossible\n");
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(!n&&!m) break;
        for(int i=0;i<n;i++)
        {
            scanf("%s",map[i]);
        }
        memset(vis,0,sizeof(vis));
        memset(vis2,0,sizeof(vis2));
        creat();
        vis2[end.x1][end.y1][end.flag]=-1;
        vis[start.x1][start.y1][start.flag]=-1;
        bfs();
    }
    return 0;
}


iteye_9368
关注
Prim算法之辅助数组详解
Polarixman的博客
12-18 4541
一：基本原理 首先，选择起点放入U集合。 然后重复动态增加最优边和点进入U集合的过程，直到U=V   1，起点V0进入U 2，寻找UV-U之间最优边 3，将边对边点（在V-U里）放入U里 3，循环2，3     二：具体实现 需要一个edge[i]辅助数组，记录当前U与V-U之间的边点权值，以供选择最优边点 里面由两个部分组成 edge[i]代表每个顶点Vi，
BLOXORZ 游戏攻略
编制者的专栏
01-24 4118
玩的方法如下：1、方向键控制滚动方向2、空格键交替选择分开的小箱子3、每一关都有一个密码位于右上方，你可以记下来以后直接输入密码进入此关 玩之前记得看一下操作说明哦~下面附中文翻译！
poj3322 Bloxorz I
Colin_27的专栏
08-14 1228
经典的方块游戏 1 * 2 * 1的砖块  最少步数到达一个指定的洞中 很明显的bfs，状态表示时用一个p值0，1， 2分别表示砖块立起来，横躺着和竖躺着，判重时用一个三维数组即可   vis  [p状态] [行位置] [列位置] 那么每次直接从一个状态转移到另一种状态，坐标位置同时改变即可 #include #include #include #include #incl
Bloxorz I [POJ3322]
lb2003
04-16 406
题面描述 一个游戏，为一个NNN行MMM列第二矩阵，位置可能是硬地("...")、易碎地面(“EEE”)、禁地("#")、起点（“OOO”)或终点(“EEE”)
POJ - 3322 Bloxorz I(bfs+状态设计)
Falcon的博客
09-24 425
题目链接：点击查看 题目大意：模拟Bloxorz小游戏找出最优解，简单说一下规则，给出一个n*m的矩阵，其中，"#"代表墙，"X"代表起点，"O"代表终点，"E"代表脆弱道路，即承受不住立着的方块，"."代表普通道路 题目分析：因为方块总共有三种状态：立着（占1格）、竖着（占2格）、横着（占2格），我们可以将占两个的两个状态压缩到一格中，竖着的（上下分布）我们规定有效方格在上面，横着的（左右分...
POJ 3322 Bloxorz I (bfs+辅助数组+状态压缩+自己的一些搜索理解）
Hadis_yuki
07-11 891
Description Little Tom loves playing games. One day he downloads a little computer game called 'Bloxorz' which makes him excited. It's a game about rolling a box to a specific position on a special
POJ3322 Bloxorz I BFS
Kevin的博客
09-10 166
题目链接 http://poj.org/problem?id=3322 分析 每次操作，地图不会改变，变化的坐标及放置方式可以设为状态，进行BFS。 预处理出各种放置方式下，向各个方向移动后状态的变化情况。 AC代码 #include <cstdio> #include <cstring> #include <queue> using namespace st...
Bloxorz I （POJ - 3322 ，BFS + 模拟）
The___Flash的博客
08-16 393
一.题目链接： POJ-3322 二.题目大意： 翻砖块：体验 三.分析： 题目不难，把所用东西搞清楚就行了. 这里多写了一个打印路径的，供以后玩学习. 四.代码实现： 一.AC 版本 #include <set> #include <map> #include <ctime> #include <queue> #includ...
poj3322 Bloxorz 广搜BFS+地图类问题
qq_43627100的博客
08-07 174
原题处 题目思路：这道题主要是利用广搜解决“走地图”类问题，通过搜索问题状态，从走一步到走多步，最先的得到的结果一定是最小步数。 #include<iostream> #include<cmath> #include<algorithm> #include<queue> #include<cstdio> #define MAX 510 u...
图的深搜+树状数组练习 POJ 3321(JAVA)
04-14
标题中的“图的深搜+树状数组练习 POJ 3321(JAVA)”指的是一个编程题目，其中涉及到图的深度优先搜索（DFS, Depth First Search）算法和树状数组（也称为线段树，Segment Tree）的数据结构。这个题目来源于POJ...
POJ3322.rar_poj33_www.3322.se.c
09-19
在"POJ3322_Code.cpp"这个文件中，很可能包含了实现上述宽搜算法的C++代码。通过阅读和分析这个代码，我们可以了解到如何具体处理矩形方块的移动，如何构建和更新搜索空间，以及如何判断是否到达目标位置等细节。这...
POJ1426-Find The Multiple【BFS+同余模】
07-31
在代码实现上，`POJ1426-Find The Multiple【table】.cpp`可能包含了利用数组或哈希表来存储和查找结果的策略，而`POJ1426-Find The Multiple【BFS+同余模】.cpp`则是直接使用BFS和模运算的实现。文档`POJ1426-Find ...
POJ3026-Borg Maze【BFS+Prim】
07-30
在提交的代码文件“POJ3026-Borg Maze【BFS+Prim】.cpp”中，我们可以看到如何将这两种算法结合在一起，解决“Borg Maze”问题的具体实现细节。文档“POJ3026-Borg Maze【BFS+Prim】.doc”则可能包含了对解题思路的...
基于SVM算法的人民币面值识别系统：从图像处理到机器学习模型的实现与应用 · 数字图像处理
08-11
基于支持向量机(SVM)的人民币面值识别系统的设计与实现。该系统利用MATLAB GUI工具，结合数字图像处理技术和机器学习模型，能够高效识别多种面值的人民币。主要步骤包括数据集准备、图像灰度化、边缘检测、旋转矫正、形态学操作、ROI截取、加载SVM模型、面值识别及结果验证。系统目前可识别1元至100元面值，正确率达到90%以上，并可通过扩展训练数据集来提升识别精度和覆盖更多面值。 适合人群：从事图像处理、机器学习研究的技术人员，以及对人民币面值识别感兴趣的开发者。 使用场景及目标：适用于银行、自助设备、零售终端等需要快速准确识别人民币面值的场合。目标是提供一种高效、准确、易用的人民币面值识别解决方案。 其他说明：该系统不仅展示了SVM在图像分类任务中的强大能力，还通过MATLAB GUI实现了操作流程的可视化，便于用户理解和使用。未来可以通过优化算法和增加训练样本进一步提升系统性能。
ctkqiang-WangZhongZhi-62936-1753627160067.zip
08-11
点sun小白ctkqiang_WangZhongZhi_62936_1753627160067.zip
LabVIEW调用基恩士XGX8500相机实现高效画面嵌入的开源方案 权威版
08-11
如何使用LabVIEW调用基恩士XGX8500相机实现画面嵌入的技术方案。首先，文中强调了准备工作的重要性，包括安装LabVIEW及其相关驱动和SDK，获取基恩士XGX8500相机的接口文档。接着，阐述了通过调用基恩士提供的API控制相机的具体步骤，如初始化相机、设置参数、开启预览流、获取画面数据等。然后，讲解了如何将获取的画面数据嵌入到LabVIEW的程序中，通过图形界面设计使相机画面合理显示。最后，指出该方案不仅能够节省昂贵的HX软件授权费用，还因其源程序和方法的开放性，为用户提供更多定制化的可能。 适合人群：从事工业自动化、机器视觉领域的工程师和技术人员。 使用场景及目标：适用于需要集成高质量图像采集设备的工业生产和检测系统，旨在提升自动化水平和视觉信息丰富度，降低软件授权成本。 其他说明：文中附有简单代码片段，帮助读者更好地理解和实践该方案。
PANDA 真空泵 WV 1200 A、WV 1800 A 和 WV 2400 A 使用说明书.pdf
最新发布
08-11
PANDA 真空泵 WV 1200 A、WV 1800 A 和 WV 2400 A 使用说明书.pdf
基于Jenkins Pipeline实现Java项目自动化构建与发布
08-11
资源下载链接为： https://pan.quark.cn/s/22ca96b7bd39 在当今的软件开发领域，自动化构建与发布是提升开发效率和项目质量的关键环节。Jenkins Pipeline作为一种强大的自动化工具，能够有效助力Java项目的快速构建、测试及部署。本文将详细介绍如何利用Jenkins Pipeline实现Java项目的自动化构建与发布。 Jenkins Pipeline简介 Jenkins Pipeline是运行在Jenkins上的一套工作流框架，它将原本分散在单个或多个节点上独立运行的任务串联起来，实现复杂流程的编排与可视化。它是Jenkins 2.X的核心特性之一，推动了Jenkins从持续集成（CI）向持续交付（CD）及DevOps的转变。 创建Pipeline项目 要使用Jenkins Pipeline自动化构建发布Java项目，首先需要创建Pipeline项目。具体步骤如下： 登录Jenkins，点击“新建项”，选择“Pipeline”。 输入项目名称和描述，点击“确定”。 在Pipeline脚本中定义项目字典、发版脚本和预发布脚本。 编写Pipeline脚本 Pipeline脚本是Jenkins Pipeline的核心，用于定义自动化构建和发布的流程。以下是一个简单的Pipeline脚本示例： 在上述脚本中，定义了四个阶段：Checkout、Build、Push package和Deploy/Rollback。每个阶段都可以根据实际需求进行配置和调整。 通过Jenkins Pipeline自动化构建发布Java项目，可以显著提升开发效率和项目质量。借助Pipeline，我们能够轻松实现自动化构建、测试和部署，从而提高项目的整体质量和可靠性。
信捷PLC与HMI驱动的印刷机设备程序：四步进电机控制与汽缸印刷系统的开发与学习
08-11
信捷PLC与HMI驱动的印刷机设备程序，涵盖四个步进电机控制（X、Y、Z三向抓取定位放置系统）和分度转盘定位系统。程序包含详细的注释，便于理解和维护。信捷PLC采用标准工业编程语言，确保高稳定性和可靠性；HMI界面设计直观易用，增强了操作便捷性。该程序适用于表盘和电路板等印刷设备的开发，支持自动化生产和提高生产效率。 适合人群：工控爱好者、印刷设备开发者和技术人员。 使用场景及目标：①用于表盘和电路板等印刷设备的开发；②作为工控爱好者的学习参考资料；③提升自动化生产能力，优化生产流程，降低成本。 其他说明：该程序不仅为实际生产提供了技术支持，同时也帮助工控爱好者提高技术水平和实践能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值