UVa 1604 Cubic Eight-Puzzle

题目描述

这是一个三维的八数码问题变种。在一个 $3\times 3$ 的棋盘上，放置着 $8$ 个立方体，留下一个空格子。每个立方体的六个面被涂成三种颜色：蓝色（ $\text{B}$ ）、白色（ $\text{W}$ ）、红色（ $\text{R}$ ），且对立面的颜色相同。

初始时，所有立方体都以相同的方向放置：顶面和底面为白色，前面和后面为红色，左面和右面为蓝色。

在每一步操作中，可以选择一个与空格子相邻的立方体，将其滚动到空格子中，原位置变为空。滚动的方向可以是上、下、左、右。

目标是通过一系列滚动操作，使得从上方看到的立方体顶部颜色形成指定的颜色图案。

输入：包含多个数据集，以 0 0 结束。每个数据集格式如下：

• 第一行：两个整数 $x$ $y$ （空格分隔），表示初始空格子的位置（ $x$ 是列， $y$ 是行，值在 $1$ 到 $3$ 之间）
• 接下来三行：每行三个字符（ $\text{B}$ 、 $\text{W}$ 、 $\text{R}$ 或 $\text{E}$ ，空格分隔），表示目标颜色图案，其中 $\text{E}$ 表示该位置为空

输出：对每个数据集，如果在 $30$ 步内可达，输出最少步数；否则输出 -1 。

题目分析

1. 问题本质

这是一个状态空间搜索问题，类似于经典八数码问题，但有三个重要不同点：

1. 状态更复杂：每个位置不仅是空的或非空，立方体还有 $6$ 种不同的朝向状态
2. 滚动操作：移动立方体时会改变其朝向
3. 目标不唯一：目标只指定顶部颜色，不指定立方体的完整朝向

2. 状态表示

由于对立面颜色相同，立方体实际上只有 $6$ 种不同的朝向。我们可以用 $1$ 到 $6$ 表示这 $6$ 种状态：

• $1$ : $\text{WRB}$ （顶 $\text{W}$ ，前 $\text{R}$ ，左 $\text{B}$ ） - 初始状态
• $2$ : $\text{WBR}$ （顶 $\text{W}$ ，前 $\text{B}$ ，左 $\text{R}$ ）
• $3$ : $\text{RWB}$ （顶 $\text{R}$ ，前 $\text{W}$ ，左 $\text{B}$ ）
• $4$ : $\text{RBW}$ （顶 $\text{R}$ ，前 $\text{B}$ ，左 $\text{W}$ ）
• $5$ : $\text{BWR}$ （顶 $\text{B}$ ，前 $\text{W}$ ，左 $\text{R}$ ）
• $6$ : $\text{BRW}$ （顶 $\text{B}$ ，前 $\text{R}$ ，左 $\text{W}$ ）

棋盘状态可以用一个长度为 $9$ 的数组表示，每个元素为 $0$ （空位）或 $1$ 到 $6$ （立方体状态），加上空位位置信息。

3. 滚动规则

立方体滚动时，其状态会发生变化。经过推导，得到滚动规则表：

• 状态 $1$ （ $\text{WRB}$ ）：上下滚动变为状态 $3$ （ $\text{RWB}$ ），左右滚动变为状态 $6$ （ $\text{BRW}$ ）
• 状态 $2$ （ $\text{WBR}$ ）：上下滚动变为状态 $5$ （ $\text{BWR}$ ），左右滚动变为状态 $4$ （ $\text{RBW}$ ）
• 状态 $3$ （ $\text{RWB}$ ）：上下滚动变为状态 $1$ （ $\text{WRB}$ ），左右滚动变为状态 $5$ （ $\text{BWR}$ ）
• 状态 $4$ （ $\text{RBW}$ ）：上下滚动变为状态 $6$ （ $\text{BRW}$ ），左右滚动变为状态 $2$ （ $\text{WBR}$ ）
• 状态 $5$ （ $\text{BWR}$ ）：上下滚动变为状态 $2$ （ $\text{WBR}$ ），左右滚动变为状态 $3$ （ $\text{RWB}$ ）
• 状态 $6$ （ $\text{BRW}$ ）：上下滚动变为状态 $4$ （ $\text{RBW}$ ），左右滚动变为状态 $1$ （ $\text{WRB}$ ）

注意：向上滚动和向下滚动效果相同，向左滚动和向右滚动效果相同。

4. 搜索策略

由于步数限制为 $30$ ，直接 $\text{BFS}$ 可能会状态爆炸。我们采用双向 $\text{BFS}$ ：

1. 正向搜索：从初始状态开始
2. 反向搜索：从所有可能的目标状态开始

关键优化：目标状态可能有多个（最多 $2^8=256$ 个），因为每个顶部颜色对应 $2$ 种立方体状态。反向 $\text{BFS}$ 从多个起点开始，状态扩展较快，因此限制反向搜索深度为 $9$ 步，而正向搜索深度为 $21$ 步，总和 $30$ 步。

5. 算法步骤

1. 读取输入：目标颜色图案
2. 生成目标状态：对每个非空位置，根据顶部颜色生成 $2$ 种可能的立方体状态，使用 $\text{DFS}$ 生成所有组合
3. 双向 $\text{BFS}$ ：
   • 正向队列：初始状态，最大深度 $21$
   • 反向队列：所有目标状态，最大深度 $9$
   • 使用哈希表记录访问状态和步数
   • 每次选择较小的队列扩展
4. 相遇检查：当正向状态与反向状态相遇时，步数相加即为总步数
5. 输出结果：若总步数 $\le 30$ 则输出，否则输出 -1

复杂度分析

• 状态总数：每个位置 $7$ 种可能（ $0$ 到 $6$ ），理论最多 $7^9\approx 4\times 10^7$ ，但受步数限制实际访问少得多
• 双向 $\text{BFS}$ 优势：从两边搜索，每边深度减半，状态数指数级减少
• 不平衡搜索：正向 $21$ 步，反向 $9$ 步，进一步减少搜索空间
• 实际性能：在 $\text{UVA}$ 评测系统中运行时间约 $590$ ms

代码实现

// Cubic Eight-Puzzle
// UVa ID: 1604
// Verdict: Accepted
// Submission Date: 2025-12-09
// UVa Run Time: 0.590s
//
// 版权所有（C）2025，邱秋。metaphysis # yeah dot net

#include <bits/stdc++.h>
using namespace std;

const char BLUE = 'B', WHITE = 'W', RED = 'R', EMPTY = 'E';

// 上、右、下、左
const int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};

// 立方体状态：1-6表示
// 1: WRB (顶W,前R) - 初始状态
// 2: WBR (顶W,前B)
// 3: RWB (顶R,前W)
// 4: RBW (顶R,前B)
// 5: BWR (顶B,前W)
// 6: BRW (顶B,前R)
int rollCube(int state, int dir) {
    // 方向：0上，1右，2下，3左
    const int rollTable[7][4] = {
        {0, 0, 0, 0},  // 占位
        {3, 6, 3, 6},  // WRB: 上下->RWB, 左右->BRW
        {5, 4, 5, 4},  // WBR: 上下->BWR, 左右->RBW
        {1, 5, 1, 5},  // RWB: 上下->WRB, 左右->BWR
        {6, 2, 6, 2},  // RBW: 上下->BRW, 左右->WBR
        {2, 3, 2, 3},  // BWR: 上下->WBR, 左右->RWB
        {4, 1, 4, 1}   // BRW: 上下->RBW, 左右->WRB
    };
    return rollTable[state][dir];
}

map<char, vector<int>> getStatesForTopColor = {{WHITE, {1, 2}}, {RED, {3, 4}}, {BLUE, {5, 6}}};

struct State {
    int states[9];   // 0表示空位
    int emptyPos;
    int steps;
    int encode() const {
        int s = 0;
        for (int i = 0; i < 9; i++) s = s * 7 + states[i];
        return s;
    }
};

char target[3][3];

// 生成所有可能的目标状态
vector<State> getStates() {
    vector<State> result;
    vector<vector<int>> possibleStates(9);
    int emptyPos = -1;
    for (int i = 0; i < 9; i++) {
        int row = i / 3, col = i % 3;
        char color = target[row][col];
        if (color == EMPTY) {
            possibleStates[i] = {0};
            emptyPos = i;
        } else possibleStates[i] = getStatesForTopColor[color];
    }
    State base;
    base.emptyPos = emptyPos;
    base.steps = 0;
    function<void(int)> dfs = [&](int pos) {
        if (pos == 9) {
            result.push_back(base);
            return;
        }
        for (int s : possibleStates[pos]) {
            base.states[pos] = s;
            dfs(pos + 1);
        }
    };
    dfs(0);
    return result;
}

int bfs(const State& start) {
    // q[0]正向BFS, q[1]反向BFS
    queue<State> q[2];
    // visited[0]记录正向结果，visited[1]记录反向结果
    unordered_map<int, int> visited[2];
    q[0].push(start);
    visited[0][start.encode()] = 0;
    // 将目标状态放入队列
    int startCode = start.encode();
    for (const State& ts : getStates()) {
        int tsCode = ts.encode();
        if (tsCode == startCode) return 0;  // 初始状态已经是某个目标状态
        q[1].push(ts);
        visited[1][tsCode] = 0;
    }
    // 双向BFS，每边最多15步
    while (!q[0].empty() || !q[1].empty()) {
        int self;
        if (q[0].empty()) self = 1;
        else if (q[1].empty()) self = 0;
        else self = q[0].size() < q[1].size() ? 0 : 1;
        int other = 1 - self;
        // 选择较小的队列扩展（优化）
        int levelSize = q[self].size();
        for (int i = 0; i < levelSize; i++) {
            State cur = q[self].front(); q[self].pop();
            // 两个方向的步数限制不同，正向不超过21步，反向不超过9步，因为正向
            // 只有一个状态，而反向初始状态有256个
            if (!self && cur.steps >= 21) continue;
            if (self && cur.steps >= 9) continue;
            int x = cur.emptyPos / 3, y = cur.emptyPos % 3;
            for (int d = 0; d < 4; d++) {
                int nx = x + dx[d], ny = y + dy[d];
                if (nx < 0 || nx >= 3 || ny < 0 || ny >= 3) continue;
                int newEmptyPos = nx * 3 + ny;
                State next = cur;
                next.emptyPos = newEmptyPos;
                next.steps = cur.steps + 1;
                // 滚动立方体，空位的滚动方向和立方体的滚动方向相反
                int rolledState = rollCube(cur.states[newEmptyPos], (d + 2) % 4);
                next.states[cur.emptyPos] = rolledState;
                next.states[newEmptyPos] = 0;
                int code = next.encode();
                if (visited[self].count(code)) continue;
                // 检查是否与反向状态相遇
                if (visited[other].count(code)) return next.steps + visited[other][code];
                visited[self][code] = next.steps;
                q[self].push(next);
            }
        }
    }
    return -1;  // 未找到30步内的解
}

int main() {
    int x, y;
    while (cin >> x >> y && (x || y)) {
        for (int i = 0; i < 3; i++)
            for (int j = 0; j < 3; j++)
                cin >> target[i][j];
        // 构建初始状态：所有立方体状态为1 (WRB)
        State start;
        for (int i = 0; i < 9; i++) start.states[i] = 1;
        start.emptyPos = (y - 1) * 3 + (x - 1);  // x是列，y是行
        start.states[start.emptyPos] = 0;
        start.steps = 0;
        // 双向BFS
        int result = bfs(start);
        // 输出结果
        if (result > 30 || result < 0) cout << "-1\n";
        else cout << result << "\n";
    }
    return 0;
}

总结

本题是一个典型的状态空间搜索问题，通过以下技巧成功解决：

1. 合理的状态表示：将立方体朝向编码为 $1$ 到 $6$
2. 预计算滚动规则：避免复杂的几何计算
3. 双向 $\text{BFS}$ ：大幅减少搜索空间
4. 不平衡搜索深度：正向 $21$ 步，反向 $9$ 步，优化性能
5. 状态编码压缩：使用 $7$ 进制编码将状态映射为整数

这个解决方案在 $\text{UVA}$ 评测系统中以 $590$ ms 运行通过，展示了算法优化的重要性。