[dfs] aw181. 回转游戏(IDA*+代码技巧+预处理打表+输入处理+好题)

Posted 2021-07-28 Ypuyu

文章目录

• • 1. 题目来源
  • 2. 题目解析

1. 题目来源

链接：181. 回转游戏

相关链接：

• [dfs] aw180. 排书(IDA*+dfs深入理解+思维+好题)

2. 题目解析

IDA * 与代码技巧的应用，也是 IDA *的经典应用。

8 种操作，使得中间 8 个数字变成相同，按照最小字典序输出每步操作。

dfs 可能会非常深，因为操作和逆操作做一次就会抵消。但是答案应该在一个比较浅的层数中。所以就可以使用 迭代加深 来优化本题搜索答案，再引入估值函数，提前剪枝，就变成了 IDA*，更加高效。

估值函数设计：

• 每次操作会将影响中间 8 个数，进一个、出一个。
• 每次操作最好会使中间 8 个数变好一个。
• 统计中间 8 个数中出现次数最多的一个数，其次数为 cnt，则最少还需要 8-cnt 次操作才有可能使中间 8 个数变一致。
• 故可以以此作为估值函数，配合当前层数和迭代加深设定层数进行提前剪枝。

技巧：

• 显然，当前操作不能是上一步操作的逆操作，否则等价于没更改，所以在 dfs 过程中需要记录上次操作是什么操作，加一个参数 last 表示即可。
• 由于操作种类很多，但是操作方式都相同。 我们可以将每个格子编号，将每个操作的操作数映射到一维数组中，然后统一进行操作就行了。 这是个非常重要的技巧。
• 字典序最小。 就按照最小字典序 A~H 中进行搜索即可，搜到答案的话一定就是最小字典序。

手写笔记：

---

时间复杂度：$O(7^k)$ 。假设答案最少需要 $k$ 步，每次需要枚举 7 种不同操作（除了上一步的逆操作），因此最坏情况下需要枚举 $7^k$ 种方案。但加入启发函数后，实际枚举到的状态数很少。

空间复杂度：$O(n)$

---

/*
      0     1
      2     3
4  5  6  7  8  9  10
      11    12
13 14 15 16 17 18 19
      20    21
      22    23
*/

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 24;

// 8 种操作的操作数
int op[8][7] = {
    {0, 2, 6, 11, 15, 20, 22},
    {1, 3, 8, 12, 17, 21, 23},
    {10, 9, 8, 7, 6, 5, 4},
    {19, 18, 17, 16, 15, 14, 13},
    {23, 21, 17, 12, 8, 3, 1},
    {22, 20, 15, 11, 6, 2, 0},
    {13, 14, 15, 16, 17, 18, 19},
    {4, 5, 6, 7, 8, 9, 10}
};
int oppsite[8] = {5, 4, 7, 6, 1, 0, 3, 2};          // 逆操作
int center[8] = {6, 7, 8, 11, 12, 15, 16, 17};      // 中间 8 数

int q[N];               // 一维读入
int path[100];          // 方案个数

// 估价函数
int f() {
    int sum[4] = {0};
    for (int i = 0; i < 8; i ++ ) sum[q[center[i]]] ++ ;    // 统计中间 8 个数出现次数，范围在1~3
        
    int s = 0;
    for (int i = 1; i <= 3; i ++ ) s = max(s, sum[i]);  
    
    return 8 - s;
}

// 做第 x 种操作。将前 6 个向后移动，最后一个变成第一个
void operate(int 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 u, int depth, int last) {
    if (u + f() > depth) return false;
    if (!f()) return true;
    
    for (int i = 0; i < 8; i ++ ) {
        // if (i != oppsite[last]) 一开始 last = -1 这样数组下标越界
        // 这样逆操作即可，很巧妙。也可以特判 last == -1 这个特殊情况
        if (oppsite[i] != last) {                   // 如果当前操作 i，不为上次操作的逆操作时
            operate(i);
            path[u] = i;
            if (dfs(u + 1, depth, i)) return true;
            operate(oppsite[i]);                    // 恢复现场
            path[u] = 0;                            // 这个可有可无
        }
    }

    return false;
}

int main() {
    while (cin >> q[0], q[0]) {
        for (int i = 1; i < N; i ++ ) cin >> q[i];
        
        int depth = 0;
        while (!dfs(0, depth, -1)) depth ++ ;   // 传上一步做的操作
        
        if (!depth) puts("No moves needed");
        else {
            for (int i = 0; i < depth; i ++ ) printf("%c", path[i] + 'A');
            puts("");
        }
        
        printf("%d\\n", q[6]); // 中间 8 格子中相同的数字 
    }
    
    return 0;
}