P1312 [NOIP 2011 提高组] Mayan 游戏

题目描述

Mayan puzzle 是最近流行起来的一个游戏。游戏界面是一个$7$ 行 $\times 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$ 所示的局面。

输入格式

共 $6$ 行。

第一行为一个正整数 $n$，表示要求游戏通关的步数。

接下来的 $5$ 行，描述 $7\times 5$ 的游戏界面。每行若干个整数，每两个整数之间用一个空格隔开，每行以一个 $0$ 结束，自下向上表示每竖列方块的颜色编号（颜色不多于 $10$ 种，从 $1$ 开始顺序编号，相同数字表示相同颜色）。

输入数据保证初始棋盘中没有可以消除的方块。

输出格式

如果有解决方案，输出 $n$ 行，每行包含 $3$ 个整数 $x,y,g$，表示一次移动，每两个整数之间用一个空格隔开，其中 $(x,y)$ 表示要移动的方块的坐标，$g$ 表示移动的方向，$1$ 表示向右移动，$-1$ 表示向左移动。注意：多组解时，按照 $x$ 为第一关键字，$y$ 为第二关键字，$1$ 优先于 $-1$，给出一组字典序最小的解。游戏界面左下角的坐标为 $(0,0)$。

如果没有解决方案，输出一行 -1。

输入输出样例 #1

输入 #1

3
1 0
2 1 0
2 3 4 0
3 1 0
2 4 3 4 0

输出 #1

2 1 1
3 1 1
3 0 1

说明/提示

【输入输出样例说明】

按箭头方向的顺序分别为图 $6$ 到图 $11$

样例输入的游戏局面如上面第一个图片所示，依次移动的三步是：$(2,1)$ 处的方格向右移动，$(3,1)$ 处的方格向右移动，$(3,0)$ 处的方格向右移动，最后可以将棋盘上所有方块消除。

【数据范围】

对于 $30\%$ 的数据，初始棋盘上的方块都在棋盘的最下面一行；

对于 $100\%$ 的数据，$0<n\le 5$。

算法思路

• 状态表示：
• 使用矩阵$m$存储网格状态，$m[i][j]$表示第$i$列第$j$行的颜色值（$1\le i\le 5,1\le j\le 7$）。
• 数组$num[i]$记录第$i$列当前方块数量。
• 操作序列用$x[],y[],yi[]$分别存储行、列和方向（$-1$左移，$1$右移）。

核心函数：

• 消除检测（sd）：扫描全图，标记水平或垂直连续三个及以上同色方块为$0$（消除）。返回是否发生消除。 $$\text{检测条件：}\{\begin{array}{llc}m[i][j]=m[i\pm 1][j]\ne 0& \text{（垂直）}m[i][j]=m[i][j\pm 1]\ne 0& \text{（水平）}\end{array}$$
• 下落处理（xia）：消除后，每列方块下落填补空隙，更新$num$数组。
• 连锁消除（find）：递归调用sd和xia，直到无更多消除。
• 深度优先搜索（dfs）：
• 终止条件：剩余步数$js=0$时，若所有$num[i]=0$则找到解（$flag=1$）。
• 状态转移：遍历每个方块，尝试与左右相邻方块交换（需边界检查），执行连锁消除后递归搜索$js-1$步。
• 回溯机制：每次尝试前保存$m$和$num$状态，递归返回后恢复。

剪枝优化：

• 当$flag=1$时立即返回，避免无效搜索。
• 优先尝试可行操作，减少状态空间。

复杂度分析

• 时间复杂度：最坏情况$O((5\times 7{)}^n)$，每层递归尝试最多$5\times 7\times 2=70$种操作（$n$步操作）。
• 空间复杂度：$O(1)$，状态备份使用固定大小数组。

优化建议

• 剪枝增强：记录已访问状态哈希，避免重复搜索。
• 启发式搜索：优先选择可能触发更多消除的操作。
• 迭代加深：当$n$较大时，改用IDDFS（迭代加深DFS）控制深度。
• 该解法通过DFS枚举所有操作序列，结合回溯和状态恢复，确保在有限步数内找到可行解。注意网- - 格行列索引从$0$开始输出，方向$-1$/$1$对应左/右移动。

详细代码

#include
#define int long long
#define pi pair<int,int>
int dx[5]={0,0,1,-1};
int dy[5]={1,-1,0,0};
using namespace std;
int n,m[10][10],x[6],y[6],yi[6],num[10],a,flag;
bool vis[10][10];
bool check()
{
	for(int i=1;i<=5;i++)
		if(num[i])
			return 0;
	return 1;
}
bool sd()
{
	int m1[10][10];
	memcpy(m1,m,sizeof(m1));
	bool ff=0;
	for(int i=1;i<=5;i++)
		for(int j=1;j<=7;j++)
		{
			if(m1[i][j]==m1[i-1][j]&&m1[i][j]==m1[i+1][j]&&m1[i][j]!=0)
				m[i][j]=0,m[i-1][j]=0,m[i+1][j]=0,ff=1;
			if(m1[i][j]==m1[i][j+1]&&m1[i][j]==m1[i][j-1]&&m1[i][j]!=0)
				m[i][j]=0,m[i][j+1]=0,m[i][j-1]=0,ff=1;
		}
	return ff;
}
void xia()
{
	int m1[10][10];
	memcpy(m1,m,sizeof(m1));
	memset(m,0,sizeof(m));
	for(int i=1;i<=5;i++){int js=0;
		for(int j=1;j<=7;j++)
		{
			if(m1[i][j])
				m[i][++js]=m1[i][j];
		}
		num[i]=js;
	}
}
void find()
{
	if(sd())
	{
		xia();
		find();
		return;
	}
}
void dfs(int js)
{
//	for(int i=1;i<=5;i++)
//	{
//		for(int j=1;j<=num[i];j++)
//			cout<
//		cout<<'\n';
//	}
//	cout<<"-----------------------------"<<'\n';
	if(js==0&&check())
	{
		flag=1;return;
	}
	if(js==0)return;
	int m1[10][10],nn[10];
	memcpy(m1,m,sizeof(m1));
	memcpy(nn,num,sizeof(nn));
	for(int i=1;i<=5;i++)
		for(int j=1;j<=nn[i];j++)
		{
			
			if(i>1&&!m[i-1][j]){
				swap(m[i-1][j],m[i][j]);
				xia();
				find();
				x[js]=i;y[js]=j;yi[js]=-1;
				dfs(js-1);
				if(flag)return;
				memcpy(num,nn,sizeof(num));
				memcpy(m,m1,sizeof(m));
			}
			if(i<5)
			{
				swap(m[i][j],m[i+1][j]);
				xia();
				find();
				x[js]=i;y[js]=j;yi[js]=1;
				dfs(js-1);
				if(flag)return;
				memcpy(num,nn,sizeof(num));
				memcpy(m,m1,sizeof(m));
			}
		}
}
signed main()
{
	ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
	cin>>n;
	for(int i=1;i<=5;i++)
	{
		while(cin>>a&&a!=0)
		{
			m[i][++num[i]]=a;
		}
	}
	dfs(n);
	if(flag)
		for(int i=n;i>=1;i--)
			cout<<x[i]-1<<" "<<y[i]-1<<" "<<yi[i]<<'\n';
	else
		cout<<-1;
	return 0;
}