puzzle（0334）双面数局

原创 已于 2026-04-12 17:29:25 修改 · 432 阅读 · 10 ·
本内容遵循CC 4.0 BY-SA版权协议
-
GEO检测
标签
#算法 #数据结构
于 2026-04-12 00:06:49 首次发布

目录

一，双面数局

二，计算机求解

1，交换公式

2，通用操作

3，n=2

4，n=3

5，n=4

三，高阶场景

1，通用操作

2，n=5

3，n=6

一，双面数局

最强大脑 同款项目

二，计算机求解

1，交换公式

参考交换公式自动推导V6

2，通用操作


vector<Opt> getOpts(int n)
{
	vector<int>v0;
	for (int i = 0; i < n*n * 2; i++)v0.push_back(i);
	vector<Opt>ans;
	for (int i = 0; i < n; i++) {
		string optName = "第";
		optName += std::to_string(i + 1);
		optName += "行往右";
		vector<int>v = v0;
		int s1 = i * n, s2 = i * n + n * n;
		vector<int>nums;
		for (int i = s1; i < s1 + n; i++)nums.push_back(i);
		for (int i = s2; i < s2 + n; i++)nums.push_back(i);
		for (int i = 0; i < nums.size(); i++)v[nums[(i + 1) % nums.size()]] = nums[i];
		Opt opt{ { v } ,optName };
		ans.push_back(opt);
	}
	for (int i = 0; i < n; i++) {
		string optName = "第";
		optName += std::to_string(i + 1);
		optName += "列往下";
		vector<int>v = v0;
		int s1 = i, s2 = n * n * 2 - i - 1;
		vector<int>nums;
		for (int i = s1; i < s1 + n * n; i += n)nums.push_back(i);
		for (int i = s2; i > s2 - n * n; i -= n)nums.push_back(i);
		for (int i = 0; i < nums.size(); i++)v[nums[(i + 1) % nums.size()]] = nums[i];
		Opt opt{ { v } ,optName };
		ans.push_back(opt);
	}
	return ans;
}

3，n=2

int main()
{
	int n = 2;
	CubeBlock block1(0, n * n * 2);
	vector<CubeBlock>b = vector<CubeBlock>{ block1 };
	vector<Opt> v = getOpts(n);
	CubeOpt op1(b, v[0]);
	CubeOpt op2(b, v[1]);
	CubeOpt op3(b, v[2]);
	CubeOpt op4(b, v[3]);
	vector<CubeOpt>opts = { op1,op2,op3,op4 };
	for (int i = 0; i < opts.size(); i++)mans[i] = opts[i].getName();
	Cube cube(b, opts);
	cube.bfs(0, 2, 2);
	return 0;
}

输出：

2,1,0,3,4,5,6,7,
0第1行往右 0第1行往右 1第2行往右 2第1列往下 0第1行往右 1第2行往右 2第1列往下 1第2行往右 2第1列往下 0第1行往右 3第2列往下

这是交换0和2的公式

4，n=3

int main()
{
	int n = 3;
	CubeBlock block1(0, n * n * 2);
	vector<CubeBlock>b = vector<CubeBlock>{ block1 };
	vector<Opt> v = getOpts(n);
	CubeOpt op1(b, v[0]);
	CubeOpt op2(b, v[1]);
	CubeOpt op3(b, v[2]);
	CubeOpt op4(b, v[3]);
	CubeOpt op5(b, v[4]);
	CubeOpt op6(b, v[5]);
	vector<CubeOpt>opts = { op1,op2,op3,op4,op5,op6 };
	for (int i = 0; i < opts.size(); i++)mans[i] = opts[i].getName();
	Cube cube(b, opts);
	cube.bfs(0, 2, 2);
	return 0;
}

输出：

0,1,7,3,4,5,6,2,8,9,10,11,12,13,14,15,16,17,
0第1行往右 0第1行往右 4第2列往下 1第2行往右 1第2行往右 1第2行往右 4第2列往下 4第2列往下 0第1行往右 0第1行往右 0第1行往右 0第1行往右 0第1行往右 1第2行往右 1第2行往右 0第1行往右 0第1行往右 0第1行往右 0第1行往右 0第1行往右 1第2行往右

这是交换2和7的公式

化简结果：

第1行往右 *2
第2列往下
第2行往右*3
第2列往下*2
第1行往左*2
第2行往右*3

5，n=4

代码1：略

运行结果：得到0 18 19 23交换的公式（不是1个4阶置换，而是2个2阶置换）

代码2：

int main()
{
	int n = 4;
	CubeBlock block1(0, n * n * 2);
	vector<CubeBlock>b = vector<CubeBlock>{ block1 };
	vector<Opt> v = getOpts(n);
	CubeOpt op1(b, v[0]);
	CubeOpt op2(b, v[1]);
	CubeOpt op3(b, v[2]);
	CubeOpt op4(b, v[3]);
	CubeOpt op5(b, v[4]);
	CubeOpt op6(b, v[5]);
	CubeOpt op7(b, v[6]);
	CubeOpt op8(b, v[7]);
	Opt opt9{ { {19,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,23,0,20,21,22,18,24,25,26,27,28,29,30,31} } ,"【1下1右1上1左】" };
	CubeOpt op9(b, opt9);
	vector<CubeOpt>opts = { op1,op2,op3,op4,op5,op6,op7,op8,op9 };
	for (int i = 0; i < opts.size(); i++)mans[i] = opts[i].getName();
	Cube cube(b, opts);
	cube.bfs(0, 2, 3);
	return 0;
}

输出：

0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,21,19,20,22,18,23,24,25,26,27,28,29,30,31,
1第2行往右 6【1下1右1上1左】 1第2行往右 6【1下1右1上1左】 1第2行往右 1第2行往右 1第2行往右 1第2行往右 1第2行往右 1第2行往右

这是18-22-21三者轮换（顺时针旋转）的公式

化简结果：

第2行往右 
【1下1右1上1左】 
第2行往右 
【1下1右1上1左】 
第2行往左*2

我们把这个公式记作三轮换公式。

代码3：

int main()
{
	int n = 4;
	CubeBlock block1(0, n * n * 2);
	vector<CubeBlock>b = vector<CubeBlock>{ block1 };
	vector<Opt> v = getOpts(n);
	CubeOpt op1(b, v[0]);
	CubeOpt op2(b, v[1]);
	CubeOpt op3(b, v[2]);
	CubeOpt op4(b, v[3]);
	CubeOpt op5(b, v[4]);
	CubeOpt op6(b, v[5]);
	CubeOpt op7(b, v[6]);
	CubeOpt op8(b, v[7]);
	Opt opt9{ { {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,21,19,20,22,18,23,24,25,26,27,28,29,30,31} } ,"三轮换" };
	CubeOpt op9(b, opt9);
	vector<CubeOpt>opts = { op2,op9 };
	for (int i = 0; i < opts.size(); i++)mans[i] = opts[i].getName();
	Cube cube(b, opts);
	cube.bfs(0, 2, 2);
	return 0;
}

输出：

0,1,2,3,4,6,5,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
0第2行往右 1三轮换 0第2行往右 0第2行往右 1三轮换 0第2行往右 0第2行往右 0第2行往右 1三轮换 0第2行往右 0第2行往右 1三轮换 0第2行往右

这是交换5和6的公式。

化简结果：

第2行往右
【2右1下1右1上1左】 *4 
第2行往右
【2右1下1右1上1左】 *4  
第2行往左

其中，2右就是第2行往右，以此类推。

同理，还有交换4和7的公式：

第2行往右*3 
【1下1右1上1左】 
第2行往右 
【1下1右1上1左】 
第2行往右 *2
【1下1右1上1左】 
第2行往右 
【1下1右1上1左】 
第2行往左*2
【1下1右1上1左】 
第2行往右 
【1下1右1上1左】
第2行往右 *2
【1下1右1上1左】 
第2行往右 
【1下1右1上1左】 
 第2行往右 
【1下1右1上1左】 
第2行往右 
【1下1右1上1左】 
第2行往左*2

三，高阶场景

前面的校验，基本上已经形成固定的模式了，只需要数字改一改就能得到高阶的公式了。

和魔方不同的是，魔方是公式本身进行微调即可得到新公式，而双面数局是产生n=k的公式的代码微调即可得到产生n=k+1的公式的代码，但n=k的公式和n=k+1的公式之间差别还是挺大的。

1，通用操作

我们把“1下1右1上1左”这个小公式进行参数化，避免手动输入置换表


vector<Opt> getOpts(int n)
{
	vector<int>v0;
	for (int i = 0; i < n*n * 2; i++)v0.push_back(i);
	vector<Opt>ans;
	for (int i = 0; i < n; i++) {
		string optName = "第";
		optName += std::to_string(i + 1);
		optName += "行往右";
		vector<int>v = v0;
		int s1 = i * n, s2 = i * n + n * n;
		vector<int>nums;
		for (int i = s1; i < s1 + n; i++)nums.push_back(i);
		for (int i = s2; i < s2 + n; i++)nums.push_back(i);
		for (int i = 0; i < nums.size(); i++)v[nums[(i + 1) % nums.size()]] = nums[i];
		Opt opt{ { v } ,optName };
		ans.push_back(opt);
	}
	for (int i = 0; i < n; i++) {
		string optName = "第";
		optName += std::to_string(i + 1);
		optName += "列往下";
		vector<int>v = v0;
		int s1 = i, s2 = n * n * 2 - i - 1;
		vector<int>nums;
		for (int i = s1; i < s1 + n * n; i += n)nums.push_back(i);
		for (int i = s2; i > s2 - n * n; i -= n)nums.push_back(i);
		for (int i = 0; i < nums.size(); i++)v[nums[(i + 1) % nums.size()]] = nums[i];
		Opt opt{ { v } ,optName };
		ans.push_back(opt);
	}
	string optName = "1下1右1上1左";
	vector<int>v = v0;
	v[0] = n * n + n - 1, v[n * n + n - 1] = 0;
	v[n * n + n - 2] = n * n + n * 2 - 1, v[n * n + n * 2 - 1] = n * n + n - 2;
	Opt opt{ { v } ,optName };
	ans.push_back(opt);
	return ans;
}

2，n=5

代码1：

int main()
{
	int n = 5;
	CubeBlock block1(0, n * n * 2);
	vector<CubeBlock>b = vector<CubeBlock>{ block1 };
	vector<Opt> v = getOpts(n);
	CubeOpt op1(b, v[0]);
	CubeOpt op2(b, v[1]);
	CubeOpt op3(b, v[2]);
	CubeOpt op4(b, v[3]);
	CubeOpt op5(b, v[4]);
	CubeOpt op6(b, v[5]);
	CubeOpt op7(b, v[6]);
	CubeOpt op8(b, v[7]);
	CubeOpt op9(b, v[8]);
	CubeOpt op10(b, v[9]);
	CubeOpt op11(b, v[10]);
	vector<CubeOpt>opts = { op1,op2,op11 };
	for (int i = 0; i < opts.size(); i++)mans[i] = opts[i].getName();
	Cube cube(b, opts);
	cube.bfs(0, 2, 3);
	return 0;
}

输出：

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

这是一个三轮换的公式。

化简结果：

第2行往左 
【1下1右1上1左】 
第2行往右
【1下1右1上1左】 

代码2：

int main()
{
	int n = 5;
	CubeBlock block1(0, n * n * 2);
	vector<CubeBlock>b = vector<CubeBlock>{ block1 };
	vector<Opt> v = getOpts(n);
	CubeOpt op1(b, v[0]);
	CubeOpt op2(b, v[1]);
	CubeOpt op3(b, v[2]);
	CubeOpt op4(b, v[3]);
	CubeOpt op5(b, v[4]);
	CubeOpt op6(b, v[5]);
	CubeOpt op7(b, v[6]);
	CubeOpt op8(b, v[7]);
	CubeOpt op9(b, v[8]);
	CubeOpt op10(b, v[9]);
	CubeOpt op11(b, v[10]);
	Opt opt{ { {0,1,2,3,4,28,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,34,29,30,31,32,33,5,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49} } ,"三轮换" };
	CubeOpt op12(b, opt);
	vector<CubeOpt>opts = { op2,op12 };
	for (int i = 0; i < opts.size(); i++)mans[i] = opts[i].getName();
	Cube cube(b, opts);
	cube.bfs(0, 2, 2);
	return 0;
}

输出1：

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

这是交换7和8的公式

化简结果：

【2右1下1右1上1左】 *6 
 第2行往右 
【2右1下1右1上1左】 *4

输出2：

0,1,2,3,4,5,6,9,8,7,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,
0第2行往右 0第2行往右 1三轮换 0第2行往右 0第2行往右 1三轮换 0第2行往右 0第2行往右 1三轮换 0第2行往右 1三轮换 1三轮换 0第2行往右 0第2行往右 1三轮换 0第2行往右 0第2行往右 1三轮换
这是交换7和9的公式

化简结果：

【2右1下1右1上1左】 *6 
第2行往左
【2右1下1右1上1左】 *2
第2行往左*2
【2右1下1右1上1左】 *6

3，n=6

公式推导方法同上。

交换10和11的公式：

【2右1下1右1上1左】 *6  
第2行往右  
【2右1下1右1上1左】 *6

其中，2右就是第2行往右，以此类推。

PS：复原之后，正面第一行是0 1 2 3 4 5，第二行是6 7 8 9 10 11，换句话说上面这个公式就是交换正面第二行右边的2个格子。

csuzhucong
关注
所有博客导航
热门推荐
nameofcsdn的博客
12-29 1万+
。。
算法与数据结构之Floyd算法
weixin_73953650的博客
06-20 75
超详细的Floyd算法教程，一看就懂！
2026年第九届GXCPC广西大学生程序设计大赛（热身赛）题解
奇妙方程式的博客
06-15 246
题目来源：未知，可在评论区补充。
CodeQUEEN 2026 -qual- (AtCoder Beginner Contest 462)题解
最新发布
Timmylyx0518的博客
06-20 84
第六次 AK，记录一下。
百度 C++/PHP 研发一二面：一面扫八股和算法，二面开始逼近 Redis、MySQL 和秒杀设计
TechPioneer_lp的博客
06-15 207
这篇百度C++/PHP研发面经展现了后端岗位的面试进阶路径：一面侧重算法、操作系统、网络等基础（如链表判环、HTTP协议），二面则深入Redis/MySQL底层、高并发设计（如秒杀系统）。面经揭示百度筛选标准：基础合格后，重点考察缓存/数据库系统理解、高并发设计能力。建议准备时：一面夯实算法和语言基础（C++关键字/多态），二面吃透Redis/MySQL原理，并构建系统设计思维。笔试不佳仍有面试机会，但二面才是真正的能力分水岭。
《LeetCode 200 FloodFill 岛屿数量DFS解法》
2601_95366422的博客
06-15 271
LeetCode200 岛屿数量
C语言学习笔记 - 55.流程控制9 - 选择5 - if...else if多分支语句
weixin_57913829的博客
06-17 284
本文介绍了C语言中if-elseif多分支语句的核心概念和应用。该语句专门用于处理多个互斥条件的选择问题，通过自上而下依次判断表达式，从多个分支中选择且仅执行一个语句块。文章详细阐述了语法格式、执行逻辑，并提供了成绩等级划分和一元二次方程求解两个典型示例。同时指出了常见错误，如条件判断顺序错误、单独的else语句等，并对比了if-elseif与嵌套if语句的优劣，强调前者在代码简洁性和可读性方面的优势。
[LC优选算法#5] 分治:快排 | 颜色分类 | 排序数组 | 第K大元素
C++开发
06-14 355
本文介绍了基于分治思想的快速排序算法及其应用。主要内容包括：1) 分治快排与普通快排的区别，分治快排将数组分为三部分，解决了全为key值时效率退化问题；2) 通过颜色分类、排序数组和求第K大元素三个例题，详细讲解分治快排的实现和优化技巧，如随机选择基准元素；3) 特别分析了TopK问题的解法，如何在排序过程中通过区间元素数量比较快速定位目标元素。文章提供了清晰的算法图解和代码实现，展示了分治快排算法在稳定O(NlogN)时间复杂度上的优势。
C语言学习笔记20260620-数字筛选算法：排除4的倍数与含4数字
2503_92342417的博客
06-20 267
本文介绍了C语言中处理数字筛选问题的三种方法，目标是排除1到n之间4的倍数和含数字4的数。方法一使用数学取模运算逐位检查；方法二通过封装函数提高代码模块化和可读性；方法三将数字转为字符串处理。三种方法各具特点：方法一基础但效率高，方法二可读性最佳，方法三适合复杂判断条件。文章建议根据实际需求选择合适方法，其中方法二的函数封装方式在算法竞赛中最具实用性。
LeetCode 3264.K次乘运算后的最终数组I
tus00000的博客
06-17 224
如果nums的大小为n，数组中最大值为U，multiplier为m，则此算法时间复杂度为O(nlognlog。输入：nums = [2,1,3,5,6], k = 5, multiplier = 2。输入：nums = [1,2], k = 3, multiplier = 4。1 次操作后 [2, 2, 3, 5, 6]2 次操作后 [4, 2, 3, 5, 6]3 次操作后 [4, 4, 3, 5, 6]4 次操作后 [4, 4, 6, 5, 6]5 次操作后 [8, 4, 6, 5, 6]
滑动窗口最大值问题：单调队列的巧妙应用
纳兰青华的博客
06-16 330
本文介绍了使用单调队列高效解决滑动窗口最大值问题的方法。通过维护一个单调递减的双端队列存储元素索引，算法能在O(n)时间复杂度内找到每个窗口的最大值。关键步骤包括：1)维护队列单调性，移除小于新元素的队尾元素；2)检查队首元素是否超出窗口范围；3)当窗口形成时记录队首最大值。相比暴力解法的O(n×w)复杂度，这种优化方案显著提升了效率，特别适合处理大规模数据。文章结合示例详细演示了算法执行过程，并分析了复杂度，最后总结了单调队列在滑动窗口问题中的通用性。
算法总结（链表、哈希）
2503_93247646的博客
06-17 620
在文章的最后，还有一个细节需要被提及，就是虚拟头节点。无论是我们构建链表，还是做链表的算法题也好，虚拟头节点一直是我们无法回避的一个点，不是说没有虚拟头节点我们做不了，而是可以更加的方便，可以把所有的操作全部统一而且不需要考虑空链表报错的情况本篇文章就到这里结束了，希望可以对大家有所帮助~~~
需求预测终极指南：零售商品预测方法、算法与AI实践
06-16 396
需求预测（Demand Forecasting）是零售企业利用历史销售数据、市场趋势、促销计划、季节性规律和外部环境因素，通过统计模型或机器学习算法，对未来特定时间段内各SKU销售量进行系统性预测的过程。区分需求预测与相关概念：需求预测关注数量维度（预测卖多少件），销售预测关注金额维度（预测卖多少钱），两者相乘得到销售金额预测，共同构成商品预算的数据基础。需求预测不等于销售目标——目标是战略性设定，预测是数据驱动的量化估算，两者可以不同，不应强制对齐。
算法札记：归并排序
Keven_11的博客
06-16 197
摘要：本文对比了归并排序与快速排序的特性。归并排序稳定，时间复杂度稳定为O(nlogn)，但需要额外空间；快速排序不稳定，平均复杂度O(nlogn)，最坏O(n²)，但空间效率高且缓存友好。实际应用中，快排因优化技术（如三数取中）更常用，而归并排序在需要稳定性、外部排序和链表排序等场景不可替代。现代语言常采用混合策略兼顾二者优点。理解两种算法的适用场景对实际编程选型至关重要。（149字）
BP神经网络用什么训练算法(traingd、traingdm、trainlm)
dbat
06-14 211
在使用matlab来训练BP神经网络时，我们不免会疑惑，究竟要怎么选择训练函数呢？
算法札记：模拟栈、模拟队列
Keven_11的博客
06-17 251
在算法竞赛中，数组模拟数据结构往往比STL容器更具优势。数组模拟栈（用tt指针）和队列（用hh/tt指针）能显著提升性能，避免TLE，且支持清空、遍历等灵活操作。其核心代码简洁（约5行），在NOIP等竞赛中已成惯例。而priority_queue等复杂结构仍建议使用STL。选择依据：大数据量/关键比赛用手写，小数据量/O2优化环境下可用STL。这种优化策略源自竞赛圈实践，由"豆包"等大神总结推广。（149字）
强化学习Option框架：从理论到算法实施流程
qq_21493823的博客
06-15 831
Option框架是分层强化学习主流时间抽象框架，由Sutton团队1999年顶会论文提出，依托SMDP理论突破传统MDP单步动作决策局限，借助时序抽象子任务解决长时序、稀疏奖励类复杂强化学习难题。本文依托该框架基础理论与三元组数学定义，梳理原生Option、Option-Critic及衍生算法原理，拆解标准化算法实施流程，结合工程优化策略、训练缺陷与前沿改进方向，系统完成Option框架从底层理论、核心算法到工程落地的全维度梳理。
2021年CSP-X复赛真题及题解（T3：口袋）
王老师青少年编程
06-17 479
2021年CSP-X复赛真题及题解（T3：口袋）
医用超声图像模拟系统：探头位置核心算法详解
alxraves的博客
06-15 498
核心算法要点回顾开源工具与框架进一步学习路径。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值