题解 P1312 【Mayan游戏】

最新推荐文章于 2024-09-04 21:14:17 发布
最新推荐文章于 2024-09-04 21:14:17 发布
阅读量143 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/Chicago/p/9920776.html
版权

题面

过长已遮挡

题意

体面已经陈述题意（这题没有考语文阅读理解）

题解

** 我还记得我曾经给自己找的锅，给某些人讲课的时候说过一句话：体面越长的题，越简单。** 这句话没有错，我会用接下来解决这道题的思路过程，来证明这句话。

  1. 首先我们知道存在这么几种操作：

    a. 交换操作

    b. 下沉操作

    c. 消除操作

    d. 搜索操作

    e. 玩完判断

    f. 拷贝操作（回溯）

  2. 这时候可以看得出来这里面除了搜索操作，剩余的操作都是模拟，我们只需要分出多个函数进行模拟就好了。

  3. 但是思路就是如此简单的一道题我却调了一个下午。（代码量是真的大，不压横150+行代码），还是我太菜了。

  4. 因为数据量非常小，不用怎么优化也能过，但是写代码的时候一定要小心。

下沉操作

每次交换完 or 消除完都要进行的操作。

  1. 遍历图上的每一个点，如果有颜色，判断下面是否还有颜色

  2. 没有颜色：立一个\(flag\)，向下一直找到呢个有颜色的点，然后利用\(flag\)下沉到有显色点的上方。

  3. 有颜色：跳出当前列。

void update()
{
    for(int i = 1;i <= 5;++i)
    {
        int flag = 0;
        for(int j = 1;j <= 7;++j)
        {
            if(!mapp[i][j]) flag++;
            else
            {
                if(!flag) continue;
                mapp[i][j - flag] = mapp[i][j];
                mapp[i][j] = 0;
            }
        }
    }
}

消除操作

每次下沉完都要进行的操作。根据题意会有三种情况：只有横着的三个；只有竖着的三个；横着三个交叉在竖着三个之间；横着三个和竖着三个同时出现但不相交。

但是我们可以把它们归纳到一种情况，就是只要有三个连续相同的出现就加到桶里面，然后再把桶扫一遍，全部染回没有颜色，这样就消除了。

这里呢还可以加一个小优化，立一个\(flag\)。因为根据题意，消除完还要进行下沉操作，但是如果我们没有可消除，就浪费了下沉的一些时间。

代码操作非常简单，只要根据上面的分析进行模拟就好了。

bool reover()
{
    bool flag = 1;
    for(int i = 1;i <= 5;++i)
        for(int j = 1;j <= 7;++j)
        {
            if(i-1 >= 1 && i+1 <= 5 && mapp[i][j] && mapp[i][j] == mapp[i-1][j] && mapp[i][j] == mapp[i+1][j])
            {
                tong[i][j] = 1;
                tong[i-1][j] = 1;
                tong[i+1][j] = 1;
                flag = 0;
            }
            if(j-1 >= 1 && j+1 <= 7 && mapp[i][j] && mapp[i][j] == mapp[i][j-1] && mapp[i][j] == mapp[i][j+1])
            {
                tong[i][j] = 1;
                tong[i][j-1] = 1;
                tong[i][j+1] = 1;
                flag = 0;
            }
        }
    
    if(flag) return 0;

    for(int i = 1;i <= 5;++i)
        for(int j = 1;j <= 7;++j)
        {
            if(tong[i][j]) 
            {
                mapp[i][j] = 0;
                tong[i][j] = 0;
            }
        }
    
    return 1;
}

交换操作

根据题意可得，交换的流程是这样的：

交换两个点颜色 -> 下沉操作 -> 消除操作 -> 下沉操作 -> 消除操作

一直到不能再消除，交换结束。

void move(int i,int j,int flag)
{
    swap(mapp[i][j],mapp[i+flag][j]);
    update();
    while(reover()) update();
}

玩完判断

只需要扫描最后一层，如果还有颜色，肯定是没有玩完。

bool gameover()
{
    for(int i = 1;i <= 5;++i)
        if(mapp[i][1]) return 0;
    
    return 1;
}

拷贝操作（回溯）

留一个备份是为了方便我们搜索完一轮后，返回时恢复初值。

代码非常的简单容易理解。

void move(int i,int j,int flag)
{
    swap(mapp[i][j],mapp[i+flag][j]);
    update();
    while(reover()) update();
}

搜索操作

这一块是最容易出错的，但是细心一些还是能过得，毕竟这个搜索也不需要优化。

  1. 如果已经玩完了，直接输出答案，结束程序。

  2. 如果搜索长度大于等于n了，不用再往后面搜了。

  3. 留一个备份，方便一会回溯。

  4. 1和2都不成立，就继续搜。分两种情况，左搜和右搜。

    a. 左搜：首先左边界肯定要大于等于1，左边的方块还没有颜色。

    b. 右搜：首先右边界肯定要小于等于5，相邻两颜色还不能相同。

  5. 搜完一定要记得回溯

void dfs(int x)
{
    if(gameover())
    {
        for(int i = 1;i <= n;++i)
        {
            if(i != 1) cout << endl;
            cout << ans[i][1] <<" "<< ans[i][2] <<" "<< ans[i][3];
        }
        exit(0);
    }

    if(x == n+1) return;

    copy(x);

    for(int i = 1;i <= 5;++i)
        for(int j = 1;j <= 7;++j)
        {
            if(mapp[i][j])
            {
                if(i-1 >= 1 && mapp[i-1][j] == 0)
                {
                    move(i,j,-1);
                    ans[x][1] = i-1;
                    ans[x][2] = j-1;
                    ans[x][3] = -1;
                    
                    dfs(x+1);

                    for(int i = 1;i <= 5;++i)
                        for(int j = 1;j <= 7;++j)
                            mapp[i][j] = last[x][i][j];
                    
                    ans[x][1] = 0;
                    ans[x][2] = 0;
                    ans[x][3] = 0;
                }

                if(i+1 <= 5 && mapp[i][j] != mapp[i+1][j])
                {
                    move(i,j,1);
                    ans[x][1] = i-1;
                    ans[x][2] = j-1;
                    ans[x][3] = 1;
                    
                    dfs(x+1);

                    for(int i = 1;i <= 5;++i)
                        for(int j = 1;j <= 7;++j)
                            mapp[i][j] = last[x][i][j];
                    
                    ans[x][1] = 0;
                    ans[x][2] = 0;
                    ans[x][3] = 0;
                }
            }
        }
}

代码

这道题的代码挺考察耐心的，我调了两个小时才调出来AC100分的结果。

#include <bits/stdc++.h>
using namespace std;

#define il inline

int n;
int mapp[10][10],ans[10][10],last[10][10][10],tong[10][10];

il int read()
{
    int X=0,w=0; char ch=0;
    while(!isdigit(ch)) {w|=ch=='-';ch=getchar();}
    while(isdigit(ch)) X=(X<<3)+(X<<1)+(ch^48),ch=getchar();
    return w?-X:X;
}

il bool reover()
{
    bool flag = 1;
    for(int i = 1;i <= 5;++i)
        for(int j = 1;j <= 7;++j)
        {
            if(i-1 >= 1 && i+1 <= 5 && mapp[i][j] && mapp[i][j] == mapp[i-1][j] && mapp[i][j] == mapp[i+1][j])
            {
                tong[i][j] = 1;
                tong[i-1][j] = 1;
                tong[i+1][j] = 1;
                flag = 0;
            }
            if(j-1 >= 1 && j+1 <= 7 && mapp[i][j] && mapp[i][j] == mapp[i][j-1] && mapp[i][j] == mapp[i][j+1])
            {
                tong[i][j] = 1;
                tong[i][j-1] = 1;
                tong[i][j+1] = 1;
                flag = 0;
            }
        }
    
    if(flag) return 0;

    for(int i = 1;i <= 5;++i)
        for(int j = 1;j <= 7;++j)
        {
            if(tong[i][j]) 
            {
                mapp[i][j] = 0;
                tong[i][j] = 0;
            }
        }
    
    return 1;
}

il bool gameover()
{
    for(int i = 1;i <= 5;++i)
        if(mapp[i][1]) return 0;
    
    return 1;
}

il void copy (int x)
{
    for(int i = 1;i <= 5;++i)
        for(int j = 1;j <= 7;++j)
        {
            last[x][i][j] = mapp[i][j];
        }
}

il void update()
{   
    for(int i = 1;i <= 5;++i)
    {
        int flag = 0;
        for(int j = 1;j <= 7;++j)
        {
            if(!mapp[i][j]) flag++;
            else
            {
                if(!flag) continue;
                mapp[i][j - flag] = mapp[i][j];
                mapp[i][j] = 0;
            }
        }
    }
}

il void move(int i,int j,int flag)
{
    swap(mapp[i][j],mapp[i+flag][j]);
    update();
    while(reover()) update();
}

void dfs(int x)
{
    if(gameover())
    {
        for(int i = 1;i <= n;++i)
        {
            if(i != 1) cout << endl;
            cout << ans[i][1] <<" "<< ans[i][2] <<" "<< ans[i][3];
        }
        exit(0);
    }

    if(x == n+1) return;

    copy(x);

    for(int i = 1;i <= 5;++i)
        for(int j = 1;j <= 7;++j)
        {
            if(mapp[i][j])
            {
                if(i-1 >= 1 && mapp[i-1][j] == 0)
                {
                    move(i,j,-1);
                    ans[x][1] = i-1;
                    ans[x][2] = j-1;
                    ans[x][3] = -1;
                    
                    dfs(x+1);

                    for(int i = 1;i <= 5;++i)
                        for(int j = 1;j <= 7;++j)
                            mapp[i][j] = last[x][i][j];
                    
                    ans[x][1] = 0;
                    ans[x][2] = 0;
                    ans[x][3] = 0;
                }

                if(i+1 <= 5 && mapp[i][j] != mapp[i+1][j])
                {
                    move(i,j,1);
                    ans[x][1] = i-1;
                    ans[x][2] = j-1;
                    ans[x][3] = 1;
                    
                    dfs(x+1);

                    for(int i = 1;i <= 5;++i)
                        for(int j = 1;j <= 7;++j)
                            mapp[i][j] = last[x][i][j];
                    
                    ans[x][1] = 0;
                    ans[x][2] = 0;
                    ans[x][3] = 0;
                }
            }
        }
}

int main(int argc, char const *argv[])
{
    n = read();

    for(int i = 1;i <= 5;++i)
        for(int j = 1;j <= 8;++j)
        {
            int x = read();
            if(x == 0) break; 
            mapp[i][j] = x;
        }

    dfs(1);

    printf("-1\n");

    return 0;
}

转载于:https://www.cnblogs.com/Chicago/p/9920776.html

deji2217
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
洛谷P1312 Mayan游戏(NOIP 2011)
ETwinner的博客
03-21 149
题目描述 https://www.luogu.org/problemnew/show/P1312 大型模拟搜索题 主要思路就是：枚举每一步，该移的移，该消除的消除，该落下的落下，k步后，判断是否消除干净，消除干净就输出。 #include<iostream> #include<cstdio> #include<cstring> #include<algor...
题解 -NOIp2011 Day1T3 Mayan游戏(mayan.cpp/.c/.pas)
wangyixin_oier的博客
08-04 307
-NOIp2011 Day1T3 Mayan游戏(mayan.cpp/.c/.pas) 欢迎来到本蒟蒻的题解 题目 Mayan 游戏 (mayan.cpp/c/pas) 问题描述 Mayan puzzle 是最近流行起来的一个游戏。游戏界面是一个 7 行 5 列的棋盘，上面堆放着一些方块，方块不能悬空堆放，即方块必须放在最下面一行，或者放在其他方块之上。游戏通关是...
[NOIP2011]Mayan游戏 题解
diyaochang9767的博客
10-28 160
题目大意： 　　有一个5*7的方格，上面有几种颜色的方块，如果在一横行或者竖列上有连续三个或者三个以上相同颜色的方块，则它们将立即被消除，方块消除之后，消除位置之上的方块将掉落。每步移动可以且仅可以沿横向拖动某一方块一格：当拖动这一方块时，如果拖动后到达的目标位置也有方块，那么这两个方块将交换位置；如果目标位置上没有方块，那么被拖动的方块将从原来的竖列中抽出，并从目标位置上掉落，直到不...
题解 Mayan游戏
Ansicht's Blog
09-02 200
@luogu 搜索剪枝题，每一次暴力下落，暴力消除 #include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;algorithm&gt; #define N 10 #define ll long long #define max(x,y) ((x)&gt;(y) ? (x) : (y)) #define min...
NOIP2011 Mayan游戏 题解
persist
08-29 1354
描述  Mayan puzzle是最近流行起来的一个游戏。游戏界面是一个7行5列的棋盘，上面堆放着一些方块，方块不能悬空堆放，即方块必须放在最下面一行，或者放在其他方块之上。游戏通关是指在规定的步数内消除所有的方块，消除方块的规则如下： 1、每步移动可以且仅可以沿横向（即向左或向右）拖动某一方块一格：当拖动这一方块时，如果拖动后到达的位置（以下称目标位置）也有方块，那么这两个方块将交换位置
Mayan游戏 （codevs 1136）题解
05-22 141
【问题描述】 Mayan puzzle是最近流行起来的一个游戏。游戏界面是一个7行5列的棋盘，上面堆放着一些方块，方块不能悬空堆放，即方块必须放在最下面一行，或者放在其他方块之上。游戏通关是指在规定的步数内消除所有的方块，消除方块的规则如下： 1、每步移动可以且仅可以沿横向（即向左或向右）拖动某一方块一格：当拖动这一方块时，如果拖动后到达的位置（以下称目标位置）也有方块，那么这两个方...
【题解】「NOIP2011」Mayan 游戏
cqbzlydd的博客
11-30 230
solution: 一道纯模拟。由于题目范围n<=5n<=5n<=5，所以在5*7的界面里暴搜。最坏时间复杂度是70570^5705，以及消除操作和复制时353535的常数。但是由于有颜色的方块比较少，再加上可行性剪枝（作用微乎其微，但主要在于对不合法的判断），所以是可以通过的。过程中有很多无用的操作（如几个方块换来换去），但是暂时没有什么办法，而且很容易wawawa掉。 只能祈祷早日搜出正解了。毕竟回溯时仍会进入循环，寻找新的方块来进行交换。 注意回溯时要在最内层循环里还原。 #incl
python-leetcode题解之055跳跃游戏
08-21
python python_leetcode题解之055跳跃游戏
C++ 数字游戏题解解析
08-07
C++ 数字游戏题解解析
洛谷入门p1150 peter的烟题解
06-08
洛谷入门p1150 peter的烟题解
C语言-leetcode题解之第174题地下城游戏.zip
07-28
c语言 C语言_leetcode题解之第174题地下城游戏
洛谷P1724题解（请不要抄袭！）
06-17
洛谷P1427题解，若要复制or下载，请与我联系，如要改编，也请联系，若发现未经我同意的复制、下载、改编，直接举报。
mayan游戏
Rayhirox的博客
07-09 620
题解：非常暴力的一道题因为地图比较小，枚举35块所有向左拉或者向右拉总共70种情况输出一个字典序最小的一个答案，事实上是降低了深搜难度按从小到大依次搜索x和y，先向右拉，再向左拉，对于每一次拉动先交换两个方块，然后将这两列的方块全部落下，这就需要我们写一个“掉落”函数掉落完成后，进行“清除”操作，规则跟一般的三消游戏差不多清除操作必须将当前能消除的全部消除，另外消除完后还要将悬空的方块落下注意落下...
Mayan游戏
HT008的Blog
08-08 362
QAQ 思路：DFS+模拟 依次枚举每个格子，颜色不同进行交换，先下落，再进行消除 剪枝：当前有颜色的个数为1或2直接退出#include <cstdio> #include <iostream> #include <algorithm> #include <cstring> using namespace std; int col[6][8]; int ans[99][3]; int num
luoguP1312 Mayan游戏 题解(NOIP2011)
weixin_30456039的博客
04-05 78
luoguP1312 Mayan游戏 题目 #include<bits/stdc++.h> #define ll long long #define rg register #define il inline #define inf 1<<30; using namespace std; int a[10][10],b[6][10][10]; int...
[题目] Luogu P1312 Mayan游戏
weixin_30828379的博客
12-22 87
题面 题目描述 $ Mayan puzzle $是最近流行起来的一个游戏。游戏界面是一个 \(7行 \times 5列\)的棋盘，上面堆放着一些方块，方块不能悬空堆放，即方块必须放在最下面一行，或者放在其他方块之上。游戏通关是指在规定的步数内消除所有的方块，消除方块的规则如下： 1 、每步移动可以且仅可以沿横向（即向左或向右）拖动某一方块一格：当拖动这一方块时，如果拖动后到达的位置（以下称目标位置...
【NOIP2011】Mayan游戏
weixin_30611509的博客
10-22 99
本题在洛谷上的链接：https://www.luogu.org/problemnew/show/P1312 很考验代码能力的一道搜索模拟题。 首先是大体的思路，显然我们应该把状态定义为某一时刻的棋盘，然后每进行一次操作，就跳到下一个状态，这道题用广搜的话，状态不容易存储，而且要求的步数n很小，所以深搜就可以满足我们的需要。 我们搜索整张棋盘，寻找可以进行的移动，移动后就更新棋盘，该...
单向链表
最新发布
qq_69639971的博客
09-04 452
【代码】单向链表。
LeetCode LCR088.使用最小花费爬楼梯
m0_63816268的博客
09-03 1031
动态规划
洛谷P1699C++题解
07-05
对于C++题解，一般会包含以下步骤： 1. **理解题意**：分析题目描述，明确输入、输出以及限制条件。 2. **选择数据结构**：根据题目的特性和要求选择合适的数据结构，如数组、链表、栈、队列、树、图等。 3. **设计...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值