UVa 12639 Hexagonal Puzzle

题目描述

一个六边形拼图由 $7$ 个正六边形块组成，每个块的 $6$ 条边上标有数字 $1$ 到 $6$ 的一个排列（顺时针顺序给出）。
拼图是可解的，当且仅当这些块可以通过旋转（不能翻转）拼成一个蜂窝形状，使得任意两个相邻块的相邻边上的数字相同。

蜂窝形状为：中心一个六边形，周围 $6$ 个六边形分别与中心的 $6$ 条边相邻，并且周围块之间也按照顺时针方向依次相邻，形成一个闭环。

你需要判断给定的拼图是否可解。

输入格式

每个测试用例包含 $7$ 行，每行是 $1$ 到 $6$ 的一个排列，表示一个六边形块顺时针方向的边标号。
输入包含多个测试用例，直到文件结束。

输出格式

对每个测试用例，输出一行 YES 或 NO。

题目分析

这是一道典型的搜索与回溯问题。难点在于正确建模六边形之间的邻接关系。

几何建模

我们约定：

• 每个六边形的边顺时针编号为 $0,1,2,3,4,5$，其中 $0$ 号边为顶边。
• 中心块编号为 $0$，周围块按顺时针编号 $1,2,3,4,5,6$，其中 $1$ 号块在正上方。

邻接关系

根据题目隐含的几何结构，邻接关系为：

中心与周围块的邻接（中心边 $i$ 与周围块 $i+1$ 的边 $(i+3)\mathrm{mod}6$ 相邻）：

• 中心边 $0$ ↔ 块 $1$ 边 $3$
• 中心边 $1$ ↔ 块 $2$ 边 $4$
• 中心边 $2$ ↔ 块 $3$ 边 $5$
• 中心边 $3$ ↔ 块 $4$ 边 $0$
• 中心边 $4$ ↔ 块 $5$ 边 $1$
• 中心边 $5$ ↔ 块 $6$ 边 $2$

周围块之间的邻接（形成一个闭环）：

• 块 $1$ 边 $2$ ↔ 块 $2$ 边 $5$
• 块 $2$ 边 $3$ ↔ 块 $3$ 边 $0$
• 块 $3$ 边 $4$ ↔ 块 $4$ 边 $1$
• 块 $4$ 边 $5$ ↔ 块 $5$ 边 $2$
• 块 $5$ 边 $0$ ↔ 块 $6$ 边 $3$
• 块 $6$ 边 $1$ ↔ 块 $1$ 边 $4$

这 12 条邻接关系完全决定了拼图是否可解。

解题思路

算法选择

由于总状态空间不大，我们可以使用 $\text{DFS}$ + 回溯 枚举所有可能的摆放方式：

1. 枚举 $7$ 个块中的哪一个作为中心块。
2. 枚举剩余 $6$ 个块作为周围块的排列顺序（对应块 $1$ 到 $6$ 的编号）。
3. 枚举每个周围块的旋转（$6$ 种可能）。
4. 在放置过程中，利用邻接关系剪枝，一旦违反立即回溯。

剪枝策略

• 中心匹配：放置周围块时，立即检查它与中心块的邻接边数字是否相等。
• 相邻周围块匹配：放置第 $pos$ 个周围块时（$pos\ge 1$），检查它与前一个周围块的邻接边数字是否相等。
• 最后闭环检查：放置完所有 $6$ 个周围块后，检查块 $6$ 与块 $1$ 的邻接边是否相等。

由于每次剪枝都会过滤掉大量无效分支，实际搜索非常快。

复杂度分析

最坏情况枚举：$7\times 6!\times 6^6\approx 2.35\times 10^8$，但剪枝后远小于此，对于 $10^2$ 量级的测试用例完全可行。

代码实现

// Hexagonal Puzzle
// UVa ID: 12639
// Verdict: Accepted
// Submission Date: 2026-05-31
// UVa Run Time: 0.030s
//
// 版权所有（C）2026，邱秋。metaphysis # yeah dot net

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

vector<vector<int>> pieces(7, vector<int>(6));
bool used[7];
int centerIdx;
int order[6];   // order[0]=块1, order[1]=块2, ..., order[5]=块6
int rot[6];     // 每个周围块的旋转量

// 获取块 idx 旋转 r 后第 side 条边的数字
int getVal(int idx, int r, int side) {
    return pieces[idx][(side + r) % 6];
}

bool dfs(int pos) {
    if (pos == 6) {
        // 检查闭环：块6边1 ↔ 块1边4
        int b6 = order[5], b1 = order[0];
        return getVal(b6, rot[5], 1) == getVal(b1, rot[0], 4);
    }
    
    for (int i = 0; i < 7; i++) {
        if (i == centerIdx || used[i]) continue;
        used[i] = true;
        order[pos] = i;
        
        for (int r = 0; r < 6; r++) {
            // 约束1：与中心匹配（中心边pos 对应 周围块pos+1的边 (pos+3)%6）
            int centerVal = pieces[centerIdx][pos];
            int surrSide = (pos + 3) % 6;
            if (getVal(i, r, surrSide) != centerVal) continue;
            
            // 约束2：与前一个周围块匹配
            if (pos >= 1) {
                int prev = order[pos - 1];
                int prevRot = rot[pos - 1];
                int prevSide, curSide;
                
                // 根据pos确定邻接边对
                if (pos == 1) {      // 块1边2 ↔ 块2边5
                    prevSide = 2; curSide = 5;
                } else if (pos == 2) { // 块2边3 ↔ 块3边0
                    prevSide = 3; curSide = 0;
                } else if (pos == 3) { // 块3边4 ↔ 块4边1
                    prevSide = 4; curSide = 1;
                } else if (pos == 4) { // 块4边5 ↔ 块5边2
                    prevSide = 5; curSide = 2;
                } else {               // pos == 5, 块5边0 ↔ 块6边3
                    prevSide = 0; curSide = 3;
                }
                
                if (getVal(prev, prevRot, prevSide) != getVal(i, r, curSide)) continue;
            }
            
            rot[pos] = r;
            if (dfs(pos + 1)) {
                used[i] = false;
                return true;
            }
        }
        used[i] = false;
    }
    return false;
}

bool solve() {
    for (centerIdx = 0; centerIdx < 7; centerIdx++) {
        memset(used, 0, sizeof(used));
        used[centerIdx] = true;
        if (dfs(0)) return true;
    }
    return false;
}

int main() {
    string line;
    while (getline(cin, line)) {
        if (line.empty()) continue;
        stringstream ss(line);
        for (int i = 0; i < 6; i++) ss >> pieces[0][i];
        for (int i = 1; i < 7; i++)
            for (int j = 0; j < 6; j++)
                cin >> pieces[i][j];
        
        cout << (solve() ? "YES" : "NO") << endl;
        cin.ignore();
    }
    return 0;
}