每周一算法：旋转游戏

题目链接

题目描述

如图 1 1 1 所示，有一个 #形的棋盘，上面有 1 , 2 , 3 1,2,3 1,2,3 三种数字各 8 8 8 个。给定 8 8 8 种操作，分别为图中的 A ∼ H \text{A}\sim \text{H} A∼H。这些操作会按照图中字母与箭头所指明的方向，把一条长度为 8 8 8 的序列循环移动 1 1 1 个单位。例如下图最左边的 # 形棋盘执行操作 A \text{A} A 时，会变为图中间的 # 形棋盘，再执行操作 C \text{C} C 后会变为图中最右边的 # 形棋盘。

图 1 \text{图 1} 图 1

现给定一个初始状态，请使用最少的操作次数，使 # 形棋盘最中间的 8 8 8 个格子里的数字相同。

输入格式

输入包括不超过 30 30 30 组测试数据。

每个测试数据只包括一行，包含 24 24 24 个整数，每相邻两个整数之间用 1 1 1 个空格隔开，表示这个 # 形棋盘的初始状态。（这些整数的排列顺序是从上至下，同一行的从左至右。

例如 1 1 1 1 3 2 3 2 3 1 3 2 2 3 1 2 2 2 3 1 2 1 3 3 \text{1 1 1 1 3 2 3 2 3 1 3 2 2 3 1 2 2 2 3 1 2 1 3 3} 1 1 1 1 3 2 3 2 3 1 3 2 2 3 1 2 2 2 3 1 2 1 3 3 表示图 1 1 1 最左边的状态。）每两组测试数据之间没有换行符。

输入文件以一行 0 0 0 结束。

输出格式

对于每组测试数据，输出两行。第一行用字符 A ∼ H \text{A}\sim \text{H} A∼H 输出操作的方法，每两个操作字符之间没有空格分开 ，如果不需要任何步数，输出 No moves needed。

第二行输出最终状态中最中间的 8 8 8 个格子里的数字。

如果有多组解，输出操作次数最少的一组解；如果仍有多组解，输出字典序最小的一组。任意相邻两组测试数据的输出之间不需输出换行符。

输入样例

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

输出样例

AC
2
DDHH
2

算法思想

根据题目描述，每一步操作有 A ∼ H \text{A}\sim \text{H} A∼H一共 8 8 8种选择，状态空间随着深度增加呈指数级别增长，但是答案序列不会太长，为了避免搜索超时，可以使用迭代加深A*（ IDA* \text{IDA*} IDA*）实现。

估价函数

首先来设计估价函数。在每个状态下，如果中间 8 8 8个格子里出现次数最多的是 x x x，一共出现了 m m m次，那么其余数字全变成 x x x，至少需要 8 − m 8-m 8−m次操作。可以用这个作为预估步数。

算法实现

再来确定搜索的基本框架，对于每个状态：

如果当前步数 + 未来估计步数>深度限制，则搜索结束，返回无解
如果到达最终状态，则搜索结束，返回有解。
对于当前状态，枚举要进行的操作 A ∼ H \text{A}\sim \text{H} A∼H
- 为了满足题目中对字典序的要求，先进行字典序小的操作
- 然后沿着该分支深入即可。

剪枝

如果当前操作跟上一次的操作相反，那么相当于没有进行任何操作，所以在枚举时，不能执行上次操作的逆操作，避免来回搜索。

例如，执行了 A \text{A} A操作，又执行了 F \text{F} F操作，棋盘没有变化。

所以需要记录一下上一步的操作last，在枚举时进行剪枝。

代码实现

cpp 复制代码

/*
       A     B
       0     1
       2     3
H4  5  6  7  8  9  10 C
       11    12
G13 14 15 16 17 18 19 D
       20    21
       22    23
       F     E
*/
#include <bits/stdc++.h>
using namespace std;
const int N = 25;
int q[N], path[100]; //path记录操作
int op[8][7] = { //记录每种操作对应的格子编号
  {0, 2, 6, 11, 15, 20, 22}, //A
  {1, 3, 8, 12, 17, 21, 23}, //B
  {10, 9, 8, 7, 6, 5, 4}, //C
  {19, 18, 17, 16, 15, 14, 13}, //D
  {23, 21, 17, 12, 8, 3, 1}, //E
  {22, 20, 15, 11, 6, 2, 0}, //F
  {13, 14, 15, 16, 17, 18, 19}, //G
  {4, 5, 6, 7, 8, 9, 10} //H
};
int center[8] = {6, 7, 8, 11, 12, 15, 16, 17}; //中间8个格子
int oppsite[8] = {5, 4, 7, 6, 1, 0, 3, 2}; //每个操作的逆操作
//估计函数，对于出现次数最多的x，返回m个数字x不同
int h() 
{
    int s[4] = {0};
    for(int i = 0; i < 8; i ++) s[q[center[i]]]++;
    int m = 0;
    for(int i = 1; i <= 3; i ++) m = max(m, s[i]);
    return 8 - m;
}
bool check() //检查是否到达最终状态
{
    for(int i = 1; i < 8; i ++)
        if(q[center[i]] != q[center[0]]) return false;
    return true;
}
void work(int x) //模拟操作x
{
    int t = q[op[x][0]];
    for(int i = 0; i < 6; i ++) q[op[x][i]] = q[op[x][i + 1]];
    q[op[x][6]] = t;
}
bool dfs(int k, int depth, int last) 
{
    if(k + h() > depth) return false;
    if(check()) return true;
    for(int i = 0; i < 8; i ++) //枚举操作，从A~H，满足字典序
    {
        if(oppsite[i] == last) continue; //是上一次的逆操作，剪枝
        work(i); //进行i操作
        path[k] = i; //记录第k步的操作
        if(dfs(k + 1, depth, i)) return true; 
        work(oppsite[i]); //恢复现场
    }
    return false;
}
int main()
{
    while(scanf("%d", &q[0]), q[0])
    {
        for(int i = 1; i < 24; i ++) cin >> q[i];
        int depth = 0;
        while(!dfs(0, depth, -1)) depth ++;
        if(depth == 0) printf("No moves needed");
        for(int i = 0; i < depth; i ++) printf("%c", 'A' + path[i]);
        printf("\n%d\n", q[6]); //输出中间8格的数字
    }
    return 0;
}