puzzle（1414）数字消除问题

csuzhucong

已于 2024-02-16 13:34:53 修改

阅读量1.7k

点赞数

文章标签：游戏

于 2022-09-17 19:28:35 首次发布

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

版权

竞数连环

最强大脑同款项目。

挑选数字组成2个队列，每次对队首的数进行消除，如果是倍数关系，就把大数除以小数，小数消掉。如果相等就都消掉。最后全部消掉。

策略：

（1）先看大的，大的容易最后消不掉

（2）碰到2个一样的数，而且是等于2个不同素数的积，而且是比较大的数，比如上图323=323=17*19，那么这2个数放在一开始直接消掉即可。

公约数列

最强大脑同款项目。

练习模式

（21）

（26）

比赛模式

简单

中等

困难

专家

约分消除

约分消除，Taptap游戏，应该也是照着最强大脑的规则做的。

不过，相比公约数列，约分消除取消了连连看规则，盲猜是作者要么不懂完整规则，要么是为了简单省事就没实现这个。

因为没有连连看规则，可以任意2个数字互相消除，所以没有难度可言。

贪心策略

（1）贪心策略一，每次拿最大的数字，是否一定有个数可以和这个数互约，使得互约之后仍然是正确状态（经过一系列操作之后能够全部约掉的状态）？

答案是否，我们在第7关很容易找到这样一个例子，4 6 6 3 3

这个例子倒是不违反，因为6可以和4互约，然后还是正确状态。

但是这个例子给我们的启发是，其中2的幂4 2 2 1 1，我们发现两组数据中最大的数不同，这样就可以设计交叉用例：

60, 150, 10, 9

这个例子中，必须是9和其他的数先互约才行，所以贪心策略一不成立。

（2）贪心策略二，每次拿拥有最多质因子（重复的计重）的数，是否一定有个数可以和这个数互约，使得互约之后仍然是正确状态？

重复的计重的意思是，比如12有3个质因子，分别是2 2 3

暴力策略

如果数据做的比较弱的话，任取2个数互约都行，也就是说一直乱点就可以了。

第26关亲测，只要大概记住格子位置不看数字，闭着眼睛疯狂乱点只需要18秒就能完成。

因为数据太水没意思，所以没继续玩了。

Threes

apk下载：资源分享汇总_csuzhucong的博客-CSDN博客_上海各区gm资源汇总

这个游戏和2048游戏的相似度很高，但是比2048难很多。

规则：1和2可以合并成3，从3开始两个一样的数字可以合并变成翻倍的数字

Twenty

APK下载：资源分享汇总

这个游戏分单人版和双人版。

双人版

有一个很搞笑的事情就是，如果2个人都没有到达20的能力，那么玩的比较快的反而很容易因为数字越过边界而输掉。

单人版

下面2张图片是我玩的某一局的截图

上面2张图片展示的就是我的诀窍，那就是永远保持U字形。

这样有4个好处：

（1）极大地降低了方块直接连接的数量和程度

（2）即使是连接起来的方块也几乎都是活动自由的

（3）表面积大，即几乎所有格子都是可直接访问的

（4）界面无障碍，把一个格子移到另外一个地方都是走直线，不会被其他格子挡住，这样就减少了操作时间

所以关键问题是，如何维持这个形状。

如果手速和眼速不够快的话，就只能依靠频繁暂停了。

我的记录：

四格方块大消除

4399在线play

可以把数字放入空格，也可以叠加到一个格子上（数字相加），相邻2个数字相等即可消除。

数字只能叠加到100，大于100则不能叠加。

策略

不要轻易的平摊，适当的叠加，在一定条件下直接叠到100。

开局托儿所

1，游戏规则

（1）开局

16行10列的表格，每个格子的数字是1-9

（2）操作

每次任选1个矩形，如果矩形内的数字和为10，则把矩形内所有数字改成0

示例：

9   5   4   9   3   6   6   3   4   5
5   9   1   5   8   2   7   3   2   5
3   5   3   7   1   7   6   2   4   5
5   7   8   6   7   4   7   4   6   9
1   3   4   9   5   5   2   2   4   1
6   1   7   6   6   5   1   5   6   9
3   2   5   5   4   4   4   3   4   1
5   2   2   7   5   7   1   4   6   6
9   1   4   8   3   6   3   5   7   1
6   3   9   2   3   6   2   5   5   7
4   1   8   8   2   5   1   9   8   4
6   1   5   2   5   3   9   6   7   9
8   7   9   8   2   2   5   9   4   3
4   2   2   8   6   4   5   4   7   9
2   8   7   2   4   6   8   9   8   9
1   3   2   6   4   4   9   7   5   8

6 9 1 4 4 4 1 2 7 1
5 8 1 5 5 2 8 5 8 6
7 3 9 2 8 9 6 1 8 8
7 4 9 7 4 1 1 5 4 7
4 3 3 5 4 2 3 8 9 2
9 6 1 7 6 3 9 9 4 6
9 8 6 2 5 2 8 4 4 9
3 6 6 1 5 2 7 8 1 8
4 7 6 3 6 3 2 5 2 8
6 2 9 4 4 4 7 2 8 3
9 4 4 8 5 5 8 9 8 8
7 7 8 3 8 9 1 3 3 1
8 9 5 1 8 8 4 1 7 5
9 2 2 7 4 9 5 6 8 9
7 5 6 7 3 3 6 9 2 7
2 6 6 2 7 5 7 1 5 3

2，贪心算法

我们先用贪心算法试一下，能消除到什么程度。

这里用的是一个不太严格的贪心算法，也就是肉眼所到之处，看到啥就消除啥。

（1）消除横着的或者竖着的2个或者3个

（2）继续消除，这一轮形状会比较多

（3）继续消除

（4）无法消除的数字

还有45个数字无法消除

3，枚举算法

我们用枚举算法试一下，可以消除到什么程度

代码：

vector < vector<int>>v2;
int id = 0;
void cal(vector<vector<int>>& v)
{
	for (int r = 0; r < 16; r++) {
		for (int r2 = r; r2 < 16; r2++) {
			for (int c = 0; c < 10; c++) {
				for (int c2 = c; c2 < 10; c2++) {
					int s = 0;
					for (int i = r; i <= r2; i++) {
						for (int j = c; j <= c2; j++) {
							s += v[i][j];
						}
					}
					if (s > 10)break;
					if (s == 10) {
						++id;
						for (int i = r; i <= r2; i++) {
							for (int j = c; j <= c2; j++) {
								if (v[i][j] != 0) {
									v[i][j] = 0;
									v2[i][j] = id;
								}								
							}
						}
						cout << "r:" << r << "to" << r2 << endl;
						cout << "c:" << c << "to" << c2 << endl;
						//for (int i = 0; i < 16; i++) {
						//	for (int j = 0; j < 10; j++) {
						//		cout << v[i][j];
						//	}
						//	cout << endl;
						//}
						cout << endl << endl;
						return;
					}
				}
			}
		}
	}
}
template<typename T>
static inline void read(T& x)
{
	while (!(cin >> x)) { // only cin type T, ignore other info
		cin.clear();
		cin.ignore();
	}
}
int main() {
	vector<vector<int>>v(16,vector<int>(10));
	v2 = v;
	for (int i = 0; i < 16; i++) {
		for (int j = 0; j < 10; j++) {
			read(v[i][j]);
		}
	}	
	for (int i = 0; i < 100; i++) {
		cal(v);
	}
	for (int i = 0; i < 16; i++) {
		for (int j = 0; j < 10; j++) {
			cout << v2[i][j]<<" ";
		}
		cout << endl;
	}
	return 0;
}

输入：

输出：

r:0to1
c:9to9

r:0to2
c:8to8

r:0to4
c:8to8

r:0to6
c:8to8

r:1to1
c:1to2

r:0to2
c:1to1

r:0to4
c:1to1

r:0to10
c:1to1

r:0to13
c:1to1

r:1to1
c:0to3

r:1to1
c:0to5

r:1to1
c:0to7

r:0to2
c:7to9

r:0to4
c:8to9

r:0to6
c:8to9

r:1to2
c:1to3

r:3to5
c:6to6

r:1to3
c:6to7

r:0to6
c:6to6

r:0to6
c:6to7

r:0to7
c:7to8

r:0to9
c:7to7

r:4to4
c:4to5

r:4to6
c:0to0

r:3to7
c:0to0

r:4to6
c:4to4

r:6to6
c:0to3

r:8to8
c:6to8

r:8to8
c:4to9

r:4to10
c:4to4

r:8to9
c:3to3

r:8to11
c:3to3

r:9to10
c:0to0

r:10to10
c:6to7

r:10to12
c:5to5

r:8to13
c:5to5

r:7to9
c:4to6

r:6to7
c:4to9

r:4to9
c:4to8

r:3to14
c:5to5

r:11to11
c:1to4

r:1to12
c:4to4

r:1to2
c:0to5

r:0to15
c:5to5

r:0to9
c:4to9

r:0to14
c:4to4

r:12to13
c:4to6

r:13to13
c:1to3

r:8to14
c:3to3

r:8to15
c:3to4

r:14to14
c:0to1

0 6 0 0 45 44 19 13 2 1
10 5 5 10 11 11 12 12 2 1
43 6 16 16 42 43 18 13 2 13
25 7 0 0 42 40 17 18 3 14
24 7 0 0 23 23 17 20 3 14
24 8 0 0 26 39 17 20 4 15
24 8 27 27 26 38 19 20 4 15
25 8 0 0 30 37 37 21 21 38
0 8 0 31 29 29 28 22 28 29
33 8 0 31 30 36 37 22 39 45
33 8 0 32 30 35 34 34 0 0
0 9 41 32 41 35 0 0 0 0
0 9 0 49 42 35 47 0 0 0
0 9 48 48 46 36 47 0 0 0
51 51 0 49 46 40 0 0 0 0
0 0 0 50 50 44 0 0 0 0

剩余43个，单论个数的话，居然比我人工做的还好。。。