USACO: Magic Squares

最新推荐文章于 2025-01-21 10:22:25 发布

Geterns

最新推荐文章于 2025-01-21 10:22:25 发布

阅读量241

点赞数

CC 4.0 BY-SA版权

分类专栏： Hash search 文章标签： colors transformation permutation basic exchange output

本文链接：https://blog.youkuaiyun.com/Geterns/article/details/6097372

search 同时被 2 个专栏收录

10 篇文章

订阅专栏

Hash

2 篇文章

订阅专栏

本文介绍了一个基于平面的魔方版本——魔法方块，并详细解释了其配置变化的三种基本转换方法：交换顶底行(A)、单次右旋(B)及中间四格顺时针旋转(C)。通过哈希函数与广度优先搜索(BFS)算法，实现从初始配置到目标配置的最短路径计算。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Magic Squares
IOI'96

Following the success of the magic cube, Mr. Rubik invented its planar version, called magic squares. This is a sheet composed of 8 equal-sized squares:

1	2	3	4
8	7	6	5

In this task we consider the version where each square has a different color. Colors are denoted by the first 8 positive integers. A sheet configuration is given by the sequence of colors obtained by reading the colors of the squares starting at the upper left corner and going in clockwise direction. For instance, the configuration of Figure 3 is given by the sequence (1,2,3,4,5,6,7,8). This configuration is the initial configuration.

Three basic transformations, identified by the letters `A', `B' and `C', can be applied to a sheet:

'A': exchange the top and bottom row,
'B': single right circular shifting of the rectangle,
'C': single clockwise rotation of the middle four squares.

Below is a demonstration of applying the transformations to the initial squares given above:

8	7	6	5
1	2	3	4

4	1	2	3
5	8	7	6

1	7	2	4
8	6	3	5

All possible configurations are available using the three basic transformations.

You are to write a program that computes a minimal sequence of basic transformations that transforms the initial configuration above to a specific target configuration.

PROGRAM NAME: msquare

INPUT FORMAT

A single line with eight space-separated integers (a permutation of (1..8)) that are the target configuration.

SAMPLE INPUT (file msquare.in)

2 6 8 4 5 7 3 1

OUTPUT FORMAT

Line 1:	A single integer that is the length of the shortest transformation sequence.
Line 2:	The lexically earliest string of transformations expressed as a string of characters, 60 per line except possibly the last line.

SAMPLE OUTPUT (file msquare.out)

7
BCABCCB

思路：

哈希（我用的哈希函数是康托展开）+BFS

话说哈希确实是一个极有探究价值的东东，康托用来哈希组合状态是今天才学的，懂了一点原理之后，康托函数也是自己鼓捣出来的，弄好之后再和书上的比较，发现我的思路略微不同，不过效率也不差呀！

提交的第一个版本顺利通过所有测试，最慢的一个也就0.043s

然后我看代码有点冗长（A、B、C三个函数并排展开写），就写了个函数指针数组来缩减代码，结果提交后奇怪地出现了越界错误，注意，下面的代码是第二个版本的，maxsize加了10之后又通过了测试，最慢0.067s，看来简洁的东西不一定有效率啊

输出字符串是逆向的，所以我干脆用字符指针倒移，这样算是违规操作吧？嘿嘿

最后，我在写这个题解的时候才发现一个郁闷的问题：我忘了"60 per line"这事，但是程序通过了测试！难道数据太弱了？

不过想想也是，按照完全的操作三叉树，60层深度，3^60已经达到了恐怖的42391158275216203514294433201，大概是4*10E28，就算中间剪掉了很多枝叶，60的深度也应该足够覆盖全部状态8!(40320)了吧？可见做事还是要经大脑好点……

/* ID: geterns1 PROG: msquare LANG: C++ */ #include <iostream> #include <fstream> #include <cstdio> #include <cmath> #include <cstdlib> #include <cstring> #include <algorithm> using namespace std; const int maxsize = 40320 + 10; const int factor[] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320}; short com[maxsize][8]; int pos = 0, len = 0; //queue bool chck[maxsize] = {}; //state int prv[maxsize]; short opr[maxsize]; //the previous state and operation int hlp[9]; int cantor(short com[]){ int result = 0; for (int i = 1; i <= 8; i ++) hlp[i] = i - 1; for (int i = 0; i < 8; i ++){ result += hlp[com[i]] * factor[7 - i]; for (int j = com[i] + 1; j <= 8; j ++) hlp[j] --; } return result; } void A(short com[], short res[]){ for (int i = 0; i < 8; i ++) res[i] = com[7 - i]; } void B(short com[], short res[]){ res[0] = com[3]; res[7] = com[4]; for (int i = 0; i < 3; i ++) res[i + 1] = com[i]; for (int i = 6; i > 3; i --) res[i] = com[i + 1]; } void C(short com[], short res[]){ res[0] = com[0]; res[3] = com[3]; res[4] = com[4]; res[7] = com[7]; res[1] = com[6]; res[2] = com[1]; res[5] = com[2]; res[6] = com[5]; } int main(){ freopen("msquare.in", "r", stdin); freopen("msquare.out", "w", stdout); // short tar[8]; int idx; for (int i = 0; i < 8; i ++) scanf("%hd", tar + i); idx = cantor(tar); //initialize the queue for (int i = 0; i < 8; i ++) com[pos][i] = i + 1; len ++; chck[0] = true; //BFS void (* func[])(short [], short []) = {A, B, C}; int poshlp, lenhlp, idxhlp1, idxhlp2; while (true){ poshlp = pos + len; lenhlp = 0; for (int i = 0; i < len; i ++){ idxhlp1 = cantor(com[pos + i]); for(int j = 0; j < 3; j ++){ func[j](com[pos + i], com[poshlp + lenhlp]); idxhlp2 = cantor(com[poshlp + lenhlp]); if (!chck[idxhlp2]){ lenhlp ++; chck[idxhlp2] = true; prv[idxhlp2] = idxhlp1; opr[idxhlp2] = j; } } } if (chck[idx]) break; pos = poshlp; len = lenhlp; } //print int steps = 0; char str[maxsize], *ptr, map[] = "ABC"; ptr = str + maxsize - 1; *(ptr --) = '/0'; while (idx){ *(ptr --) = map[opr[idx]]; idx = prv[idx]; steps ++; } printf("%d/n%s/n", steps, ptr + 1); // fclose(stdin); fclose(stdout); return 0; }