UVa 1352 Colored Cubes

题目描述

有 $n$ 个彩色立方体，所有立方体尺寸相同但可能着色不同。每个立方体的每个面都有单一颜色，不同面的颜色可能相同也可能不同。

如果可以通过旋转其中一个立方体使得两个立方体看起来完全相同，则称这两个立方体是 相同着色 的。如果一个立方体集合中任意两个立方体都是相同着色的，则称该集合是相同着色的。

立方体与其镜像不一定相同着色。

可以通过重新涂色某些面使得给定的立方体集合变为相同着色。题目要求计算最少需要重新涂色的面数。

输入格式

输入包含多个数据集。每个数据集由标头和数据体组成：

• 标头：一个正整数 $n$ ($1\le n\le 4$)
• 数据体：$n$ 行，每行包含 $6$ 个颜色名称

输入以包含单个 $0$ 的行结束。

输出格式

对于每个数据集，输出使立方体集合相同着色所需的最少重新涂色面数。

题目分析

问题本质

本题的核心在于找到一种旋转方式，使得所有立方体在某个共同的朝向下的差异最小，然后通过重新涂色消除这些差异。

关键难点

1. 立方体旋转：立方体有 $24$ 种不同的旋转方式
2. 颜色匹配：需要找到最优的旋转组合，使得所有立方体在对应面上的颜色尽可能一致
3. 暴力枚举可行性：由于 $n\le 4$，可以暴力枚举所有可能的旋转组合

解题思路

1. 旋转表示：预先计算立方体的 $24$ 种旋转，每种旋转用一个长度为 $6$ 的排列表示
2. 枚举策略：固定第一个立方体的朝向，枚举其他 $n-1$ 个立方体的所有可能旋转
3. 代价计算：对于每种旋转组合，计算每个面需要重新涂色的次数：
   • 对于每个面位置，统计该位置出现次数最多的颜色
   • 该面需要重新涂色的次数为 $n-\text{最大出现次数}$
4. 结果优化：在所有旋转组合中寻找最小的重新涂色面数

算法复杂度

• 旋转组合数：$24^{n-1}$
• 当 $n=4$ 时：$24^3=13824$ 种组合
• 每次组合计算需要 $O(n\times 6)$ 时间
• 总体复杂度在可接受范围内

代码实现

// Colored Cubes
// UVa ID: 1352
// Verdict: Accepted
// Submission Date: 2025-11-06
// UVa Run Time: 0.850s
//
// 版权所有（C）2025，邱秋。metaphysis # yeah dot net

#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <algorithm>
#include <climits>
#include <functional>

using namespace std;

// 预定义的 24 种旋转映射
// 面的物理位置：0:前, 1:右, 2:上, 3:下, 4:左, 5:后
const int ROTATIONS[24][6] = {
    // 以 0 面（前）为基准的 4 种旋转
    {0, 1, 2, 3, 4, 5}, {0, 2, 4, 1, 3, 5}, {0, 4, 3, 2, 1, 5}, {0, 3, 1, 4, 2, 5},
    // 以 1 面（右）为前
    {1, 5, 2, 3, 0, 4}, {1, 2, 0, 5, 3, 4}, {1, 0, 3, 2, 5, 4}, {1, 3, 5, 0, 2, 4},
    // 以 2 面（上）为前  
    {2, 1, 5, 0, 4, 3}, {2, 5, 4, 1, 0, 3}, {2, 4, 0, 5, 1, 3}, {2, 0, 1, 4, 5, 3},
    // 以 3 面（下）为前
    {3, 1, 0, 5, 4, 2}, {3, 0, 4, 1, 5, 2}, {3, 4, 5, 0, 1, 2}, {3, 5, 1, 4, 0, 2},
    // 以 4 面（左）为前
    {4, 0, 2, 3, 5, 1}, {4, 2, 5, 0, 3, 1}, {4, 5, 3, 2, 0, 1}, {4, 3, 0, 5, 2, 1},
    // 以 5 面（后）为前
    {5, 4, 2, 3, 1, 0}, {5, 2, 1, 4, 3, 0}, {5, 1, 3, 2, 4, 0}, {5, 3, 4, 1, 2, 0}
};

// 应用旋转到立方体
void applyRotation(const vector<string>& original, vector<string>& result, int rotationIndex) {
    for (int i = 0; i < 6; i++) {
        result[i] = original[ROTATIONS[rotationIndex][i]];
    }
}

int main() {
    int cubeCount;
    while (cin >> cubeCount && cubeCount != 0) {
        // 读取并重新映射输入数据
        vector<vector<string>> cubes(cubeCount, vector<string>(6));
        for (int i = 0; i < cubeCount; i++) {
            vector<string> inputColors(6);
            for (int j = 0; j < 6; j++) {
                cin >> inputColors[j];
            }
            // 重新映射到内部表示：0:前, 1:右, 2:上, 3:下, 4:左, 5:后
            cubes[i][0] = inputColors[0]; // 前
            cubes[i][1] = inputColors[1]; // 右  
            cubes[i][2] = inputColors[2]; // 上
            cubes[i][3] = inputColors[3]; // 下
            cubes[i][4] = inputColors[4]; // 左
            cubes[i][5] = inputColors[5]; // 后
        }

        // 单个立方体不需要重新涂色
        if (cubeCount == 1) {
            cout << 0 << endl;
            continue;
        }

        int minRepaint = INT_MAX;
        vector<int> rotationIndices(cubeCount, 0);
        rotationIndices[0] = 0; // 固定第一个立方体的旋转

        // 深度优先搜索枚举所有旋转组合
        function<void(int)> depthFirstSearch = [&](int currentCube) {
            if (currentCube == cubeCount) {
                // 计算当前旋转组合下的重新涂色次数
                int totalRepaint = 0;
                for (int face = 0; face < 6; face++) {
                    map<string, int> colorFrequency;
                    int maxFrequency = 0;
                    for (int cubeIdx = 0; cubeIdx < cubeCount; cubeIdx++) {
                        vector<string> rotatedCube(6);
                        applyRotation(cubes[cubeIdx], rotatedCube, rotationIndices[cubeIdx]);
                        string color = rotatedCube[face];
                        colorFrequency[color]++;
                        maxFrequency = max(maxFrequency, colorFrequency[color]);
                    }
                    totalRepaint += cubeCount - maxFrequency;
                }
                minRepaint = min(minRepaint, totalRepaint);
                return;
            }

            // 枚举当前立方体的所有可能旋转
            for (int rotation = 0; rotation < 24; rotation++) {
                rotationIndices[currentCube] = rotation;
                depthFirstSearch(currentCube + 1);
            }
        };

        depthFirstSearch(1); // 从第二个立方体开始枚举
        cout << minRepaint << endl;
    }

    return 0;
}

代码说明

主要数据结构

• ROTATIONS：预定义的 $24$ 种旋转映射
• cubes：存储所有立方体的颜色信息
• rotationIndices：记录每个立方体当前使用的旋转索引

核心函数

• applyRotation：将指定的旋转应用到立方体
• depthFirstSearch：深度优先搜索枚举所有可能的旋转组合

算法流程

1. 读取输入并重新映射到内部表示
2. 对于多立方体情况，使用 $\text{DFS}$ 枚举旋转组合
3. 对每种组合计算重新涂色代价
4. 输出最小代价

总结

本题通过暴力枚举所有可能的旋转组合，结合简单的统计方法找到了最优解。关键在于正确理解立方体旋转的数学表示和高效枚举所有可能性。由于 $n$ 的限制较小，暴力搜索在时间上是可行的。