Mayan游戏 ————NOIP2011年提高组最后一题

最新推荐文章于 2022-07-22 18:42:47 发布

幻想———繁华

最新推荐文章于 2022-07-22 18:42:47 发布

阅读量283

点赞数

分类专栏： NOIP

本文链接：https://blog.csdn.net/qq_43002849/article/details/86628617

版权

NOIP 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

首先在看之前说一句，这是一道非常难的搜索，请做好心理准备。

我们看一下题目：

Mayan puzzle是最近流行起来的一个游戏。游戏界面是一个7 行\times 5×5列的棋盘，上面堆放着一些方块，方块不能悬空堆放，即方块必须放在最下面一行，或者放在其他方块之上。游戏通关是指在规定的步数内消除所有的方块，消除方块的规则如下：

1 、每步移动可以且仅可以沿横向（即向左或向右）拖动某一方块一格：当拖动这一方块时，如果拖动后到达的位置（以下称目标位置）也有方块，那么这两个方块将交换位置（参见输入输出样例说明中的图6到图7 ）；如果目标位置上没有方块，那么被拖动的方块将从原来的竖列中抽出，并从目标位置上掉落（直到不悬空，参见下面图1 和图2）；

2 、任一时刻，如果在一横行或者竖列上有连续三个或者三个以上相同颜色的方块，则它们将立即被消除（参见图1 到图3）。

注意：

a) 如果同时有多组方块满足消除条件，几组方块会同时被消除（例如下面图4 ，三个颜色为1 的方块和三个颜色为 2 的方块会同时被消除，最后剩下一个颜色为2的方块）。

b) 当出现行和列都满足消除条件且行列共享某个方块时，行和列上满足消除条件的所有方块会被同时消除（例如下面图5 所示的情形，5 个方块会同时被消除）。

3 、方块消除之后，消除位置之上的方块将掉落，掉落后可能会引起新的方块消除。注意：掉落的过程中将不会有方块的消除。

上面图1 到图 3 给出了在棋盘上移动一块方块之后棋盘的变化。棋盘的左下角方块的坐标为（0, 0 ），将位于（3, 3 ）的方块向左移动之后，游戏界面从图 1 变成图 2 所示的状态，此时在一竖列上有连续三块颜色为4 的方块，满足消除条件，消除连续3 块颜色为4 的方块后，上方的颜色为3 的方块掉落，形成图 3 所示的局面。

以上是讨厌的题目。

好了接下来我们来分析题意：

题目也就是让你开心消消乐，每出现三个竖着或者横着的同样颜色的格子就可以删去，然后上面的格子就会掉下来。

一开始我的思路，非常简单！爆搜！！！！

然后看到了TLE。

直接喷了一口血。

现在我来解释一下过程。

STEP1:首先主程序的内容并不多说，直接上代码。

注意点：读入0就推出输出，每次都用map数组储存当前的状态。

int main()
{
    //freopen("mayan.in","r",stdin);
   	//freopen("mayan.out","w",stdout);
    scanf("%d",&n);
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=8;j++)
        {
            int x;scanf("%d",&x);
            if(x==0)break;//毒瘤出题人弄我输入我去
            map[i][j]=x;
        }
    }
    memset(ans,-1,sizeof(ans));
    dfs(1);
    printf("-1\n");//没有解输出-1.直接输出只能有20分
    return 0;
}

好了接下来我们来分析我们的下一步思路。

怎么将连续的三个方块删除掉呢？

其实也很简单，直接上代码。

思路：如果他有连续三条一样的格子，那么我们就可以将其删掉（因为我是按中间的方块位置来定义的）。

注意：4个不能一起删掉，只能删3个。

然后将标记设为true，然后随后将其当前的map数组直接清零，map数组为零的时候也就是当前没有东西

在这里。

bool remove()//题目要求一定要行或列连续3个才能消除；但一定不能遇到3个连续的就消，一开始坑在这里了
{
    bool bk=false;//开心消消乐
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=7;j++)
        {
            if(i>=2&&i<=4&&map[i][j]==map[i-1][j]&&map[i][j]==map[i+1][j]&&map[i][j])
            {
                xiaochu[i-1][j]=1;xiaochu[i+1][j]=1;xiaochu[i][j]=1;
                bk=true;
            }
            if(j>=2&&j<=6&&map[i][j]==map[i][j+1]&&map[i][j]==map[i][j-1]&&map[i][j])
            {
                xiaochu[i][j]=1;xiaochu[i][j+1]=1;xiaochu[i][j-1]=1;
                bk=true;
            }
        }
    }
    if(bk==false)return 0;
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=7;j++)
        {
	        if(xiaochu[i][j])
	        {
	            xiaochu[i][j]=0;
	            map[i][j]=0;
	        } 
	    }
	}
    return 1;
}

那么这一步就是否结束了呢？

我们不难发现，每次就算削掉了之后，我们要将其在上面顶着（也就是凌空的方块给放下来）

于是便有了STEP2

具体解释在代码中

void update()//把如果在底下被消除掉的高度减去，简单来说是让每个格子不凌空。
{
    for(int i=1;i<=5;i++)
    {
        int wow=0;//这个来枚举一共有多少个东西在它的下面，那么我们就选择把这个东西复制到哪里
        for(int j=1;j<=7;j++)
        {
            if(map[i][j]==0) wow++;
            else
            {
                if(wow==0)continue;
                map[i][j-wow]=map[i][j];//将当前的颜色顶替到最下面
                map[i][j]=0;//将当前的东西清零
            }
        }
    }
}

好的，现在我们再次消除变换过的东西。

前方高能：核心部分，占到了本次代码重要度的60%，请认真听。

接下来我们来解决一下如何处理dfs函数。

首先当然是判断如果整盘东西全部都清除掉，那么是不是可以输出了？

这个应该很好理解。

if(check()==true)
    {
        for(int i=1;i<=n;i++)
        {
            if(i!=1)printf("\n");
            for(int j=1;j<=3;j++)
            {
            	printf("%d ",ans[i][j]);
            }
        }
        exit(0);
    }

check函数指的是你当前有没有消完，没有消完请你继续消。

现在贴上代码。


bool check()//确定你这一排消除完了吗？如果不是的话请你继续
{
    for(int i=1;i<=5;i++)
    {
        if(map[i][1])return 0;
    }
    return 1;
}

那我们怎么来将ans储存呢？

接下来的else更是核心，注意！

首先如果没有剪枝，我们一定会超时。

所以怎么办？

1、将没必要的状态剪掉

假如已经进行到了目标步数，那么无论你接下来怎么弄你也无法满足他的步数问题，这是第一个剪枝。

也是一个不加就死人的剪枝。

if(x==n+1) return;

然后怎么办？

我们要备份一下我们即将要回溯的东西。

copy(x);

那么copy函数是什么东西呢？

我们将一个三维数组，last[s][i][j]表示的是当前的状态中第i行第j列的数。

代码如下：

void copy(int x)//回溯时要用的原始状态，防止原来的状态被冲洗掉而难以找到新的子状态
{
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=7;j++)
        {
        	last[x][i][j]=map[i][j];
        }
    }
}

随后我们应该交换目前的数，每个位置都要尝试一下。

假如当前有东西可以挑，那么就可以换了。

高能2：剪枝，也是最难理解的部分。

只要他在最左边，就一定能换，如果不是，那么一定不要换！

于是便有了i<=4的剪枝条件。

换一个说法，如果他们两个本来就一样那换什么换啊。

接下来我们就换，也就是move

move(i,j,k)表示第i行第j列中调换k个的位置

那么我们记录当前的ans[i][j]，ans[i][j]表示的是当前第i个状态中

j=1表示的是这次我们要交换的点的横坐标，j=2表示的是这次我们要交换的点的纵坐标。j=3表示的是方向，

1表示右边，0表示左边。dfs继续加一。

然后我们回溯，因为我们已经存到了last,那么我们直接用map数组来换回去。
然后ans的值全部弄回-1。

void dfs(int x)
{
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=7;j++)
        {
            if(map[i][j])
            {
                if(i<=4&&map[i][j]!=map[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++)
	                    {
	                    	map[i][j]=last[x][i][j];//回溯
	                    }
						ans[x][1]=-1;ans[x][2]=-1;ans[x][3]=-1;//记录当前的坐标和方向
					}
	            }
            }
            if(i>=2&&map[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++)
                    {
                    	map[i][j]=last[x][i][j];
                    }
                	ans[x][1]=-1;ans[x][2]=-1;ans[x][3]=-1;
            	}
            }
        }
    }
}

好了，如果你听懂了，那么你就皆大欢喜了。

接下来的东西非常简单。

我是不是还有两个函数没有给出。

非常的简单！

以下是move函数

void move(int i,int j,int x)
{
	swap(map[i][j],map[i+x][j]);//变换一下位置来消消乐
    update();
    while(remove())//开心消消乐，while循环防止掉下来之后还有新的可消除出现
    {
    	update();
    }
}

i+x指的是新的变换目标。然后update，

也就是我们上回说的，将上面凌空的格子弄下来。

到这里就结束了

将全部代码再放一遍。

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
using namespace std;
int n,map[110][110],ans[110][8],last[110][110][110],xiaochu[110][1100];
bool remove()//题目要求一定要行或列连续3个才能消除；但一定不能遇到3个连续的就消，一开始坑在这里了
{
    bool bk=false;//开心消消乐
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=7;j++)
        {
            if(i>=2&&i<=4&&map[i][j]==map[i-1][j]&&map[i][j]==map[i+1][j]&&map[i][j])
            {
                xiaochu[i-1][j]=1;xiaochu[i+1][j]=1;xiaochu[i][j]=1;
                bk=true;
            }
            if(j>=2&&j<=6&&map[i][j]==map[i][j+1]&&map[i][j]==map[i][j-1]&&map[i][j])
            {
                xiaochu[i][j]=1;xiaochu[i][j+1]=1;xiaochu[i][j-1]=1;
                bk=true;
            }
        }
    }
    if(bk==false)return 0;
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=7;j++)
        {
            if(xiaochu[i][j])
            {
                xiaochu[i][j]=0;
                map[i][j]=0;
            } 
        }
    }
    return 1;
}

bool check()//确定你这一排消除完了吗？如果不是的话请你继续
{
    for(int i=1;i<=5;i++)
    {
        if(map[i][1])return 0;
    }
    return 1;
}
void copy(int x)//回溯时要用的原始状态，防止原来的状态被冲洗掉而难以找到新的子状态
{
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=7;j++)
        {
        	last[x][i][j]=map[i][j];
        }
    }
}
void update()//把如果在底下被消除掉的高度减去，简单来说是让每个格子不凌空。
{
    for(int i=1;i<=5;i++)
    {
        int wow=0;
        for(int j=1;j<=7;j++)
        {
            if(map[i][j]==0) wow++;
            else
            {
                if(wow==0)continue;
                map[i][j-wow]=map[i][j];
                map[i][j]=0;
            }
        }
    }
}
void move(int i,int j,int x)
{
    swap(map[i][j],map[i+x][j]);//变换一下位置来消消乐
    update();
    while(remove())//开心消消乐，while循环防止掉下来之后还有新的可消除出现
    {
    	update();
    }
}

void dfs(int x)
{
    if(check()==true)
    {
        for(int i=1;i<=n;i++)
        {
            if(i!=1)printf("\n");
            for(int j=1;j<=3;j++)
            {
            	printf("%d ",ans[i][j]);
            }
        }
        exit(0);
    }
    if(x==n+1)return;
    copy(x);//先备份
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=7;j++)
        {
            if(map[i][j])
            {
                if(i<=4&&map[i][j]!=map[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++)
                        {
                        	map[i][j]=last[x][i][j];//回溯
                        }
                        ans[x][1]=-1;ans[x][2]=-1;ans[x][3]=-1;//记录当前的坐标和方向
                    }
                }
            }
            if(i>=2&&map[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++)
                    {
                    	map[i][j]=last[x][i][j];
                    }
                	ans[x][1]=-1;ans[x][2]=-1;ans[x][3]=-1;
            	}
            }
        }
    }
}
int main()
{
    //freopen("mayan.in","r",stdin);
   	//freopen("mayan.out","w",stdout);
    scanf("%d",&n);
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=8;j++)
        {
            int x;scanf("%d",&x);
            if(x==0)break;//毒瘤出题人弄我输入我去
            map[i][j]=x;
        }
    }
    memset(ans,-1,sizeof(ans));
    dfs(1);
    printf("-1\n");//没有解输出-1.直接输出只能有20分
    return 0;
}

经过了久久八十一难，我们终于解决了这一道难题。

是不是很有满足感？

感谢您收看了这么长的一篇题解。

BY ZZJ

幻想———繁华

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Mayan游戏 ————NOIP2011年提高组最后一题

首先在看之前说一句，这是一道非常难的搜索，请做好心理准备。我们看一下题目：Mayan puzzle是最近流行起来的一个游戏。游戏界面是一个7 行\times 5×5列的棋盘，上面堆放着一些方块，方块不能悬空堆放，即方块必须放在最下面一行，或者放在其他方块之上。游戏通关是指在规定的步数内消除所有的方块，消除方块的规则如下：1 、每步移动可以且仅可以沿横向（即向左或向右）拖动某一方块一格：...
复制链接

扫一扫