puzzle（1313）彩色迭代、一触即发

csuzhucong

已于 2023-10-19 00:03:01 修改

阅读量1.2k

点赞数 1

文章标签：游戏

于 2022-08-13 16:48:13 首次发布

本文链接：https://blog.csdn.net/nameofcsdn/article/details/126321116

版权

一，彩色迭代

黑白迭代是每个格子只有01两种状态，如果换成彩色（多色），或者换成数字0-n，n>1，则是多状态迭代。

最强大脑项目是四色迭代：

我们把点击当成加1，那么颜色和数字的对应关系就是：0红 1黄 2蓝 3绿。

四色三阶

先调整成左右对称的，再按照类似黑白迭代的思路，变换第一行的点击次数，然后依次从上往下复原。

四色四阶

先弄出对称的，再完成前三行，看看最后一行是什么状态

如果是这个状态那么就简单了，第一行只把第一个格子点一下，其他格子不动，然后依次复原即可。

四色六阶

先弄成对称的：

再根据公式硬推，第一行一二三格对底层的影响分别是112 133 230，当前局面离目标是303，所以是133+230*3，即第一行的第二五格点1下，第三四格点3下，然后依次按行复原即可。

四色八阶

8*8的要弄成对称的都不容易，只能用公式硬推了。

首先算出第一行前四个格子单击一次对最后一行的影响：

20003200 02032320 00123232 03312323

算出对最后一行对称性的影响：

如20003200，就是2000-0023=2021，同理可得四个分别是2021 0011 2133 1103

现在最后一行是黄红黄黄绿绿黄黄，离对称的距离是0200

0200=0011*2+2133*2，所以点击第一行第二个格子第三个格子各2次，即可变成对称的：

算出第一行四组格子对最后一行的影响：

如20003200就是20003200+00230002=20233202，即2023（取前一半），同理可得四个分别是2023 0031 2331 3123

现在最后一行是绿黄黄黄，即0222

0222=2331*2

所以点击第一行第三个格子第六个格子各2次，再按行依次完成即可全部完成。

下面的例子来自苹果APP“翻转-统一颜色”，规则是全部同色即可，和限定一个颜色规则差不多。

三色三阶

三色四阶

还是先变成左右对称：

然后就很容易找到答案了：

n色五阶

首先复原上面4行，假设最后一行5个格子离复原分别差x1,x2,x3,x4,x5步，那么全局操作方程组的推导如下

得到的这个方程组的系数矩阵的秩为3

于是只要解3个mod n的同余方程即可。

二，同色最小步数

如果彩色迭代不设定固定的目标局面，而是只要求所有格子同色，那么最少需要点击多少次？

把点亮所有的灯的代码改一改即可：（J是单个格子的状态数）


#include<iostream>
#include<string>
#include<vector>
#include<iomanip>
#include<algorithm>
#include <cmath>
using namespace std;

int m, n, a;
int l[17];
int temp[17];
int J = 9;


int yihuo(int a, int b, int j)
{
	int ans = 0, s = 1;
	while (a > 0 && b > 0)
	{
		ans += (a % j + b % j) % j * s;
		a /= j, b /= j, s *= j;
	}
	ans += a * s + b * s;
	return ans;
}

int g(int k, int s)
{
	int t = int(pow(J * 1.0, n) + 0.1);
	return yihuo((t - 1) / (J - 1) * s, yihuo(t - 1 - k, (t - 1) / (J - 1), J), J);
}

int f(int k, int s)
{
	k = g(k, s);
	return yihuo(yihuo(k % int(pow(J * 1.0, n-1) + 0.1) * J, k, J), k / J, J);
}

bool ok(int k, int s)
{
	for (int i = 0; i < 17; i++)temp[i] = l[i];
	temp[0] = g(k,s);
	for (int i = 1; i < m; i++)
	{
		temp[i] = yihuo(temp[i] , f(temp[i - 1],s),J);
		temp[i + 1] = yihuo(temp[i + 1] , g(temp[i - 1],s),J);
	}
	temp[m] = yihuo(temp[m] , f(temp[m - 1],s),J);
	return temp[m] == (int(pow(J * 1.0, n) + 0.1) - 1) / (J - 1) * s;
}
int getSum(int k,int s)
{
	int ans = 0;
	for (int i = 0; i < 17; i++)temp[i] = l[i];
	temp[0] = g(k, s);
	for (int i = 1; i <= m; i++)
	{
		int tmp = g(temp[i - 1],s);
		while (tmp)ans += tmp % J, tmp /= J;
		temp[i] = yihuo(temp[i], f(temp[i - 1],s), J);
		temp[i + 1] = yihuo(temp[i + 1], g(temp[i - 1],s), J);
	}
	return ans;
}
void out(int k, int s)
{
	for (int i = 0; i < 17; i++)temp[i] = l[i];
	temp[0] = g(k, s);
	for (int i = 1; i <= m; i++)
	{
		int tmp = g(temp[i - 1],s);
		for (int j = 0; j < n; j++)
		{
			cout << tmp % J;
			tmp /= J;
			if (j < n - 1)cout << " ";
		}
		cout << endl;
		temp[i] = yihuo(temp[i] , f(temp[i - 1],s),J);
		temp[i + 1] = yihuo(temp[i + 1] , g(temp[i - 1],s),J);
	}
}

int main()
{
	int t = 100;
	for (int id = 1; id <= t; id++) {
		m = 3, n = 3;
		for (int i = 0; i <= 17; i++)l[i] = 0;
		for (int i = 1; i <= m; i++) {
			int s = 1;
			for (int j = 0; j < n; j++)
			{
				cin >> a;
				l[i] += a*s;
				s *= J;
			}
		}
		//cout << "PUZZLE #" << id << endl;
		int m = 123456, mk=0, mj = 0;
		for (int k = 0; k < int(pow(J * 1.0, n) + 0.1); k++)
		{
			for (int j = 0; j < J; j++) {
				if (ok(k, j) && m > getSum(k, j))m = getSum(k, j), mk = k, mj = j;
			}
		}
		out(mk, mj);
	}
	return 0;
}

输入：

0 3 3
7 7 8
5 6 6

输出：

0 7 0
3 0 0
0 2 2

即最少要点14次才能全部变成一样的数字。