0017 UVA253 骰子涂色 Cube painting 算法竞赛入门经典系列源码解析立方体24种姿态

本文链接：https://blog.csdn.net/m0_73132141/article/details/127707661

文章目录

总结

问题

在这里插入图片描述

代码

// 算法竞赛入门经典系列源码解析

// 算法竞赛入门经典第2版 P97
// 算法竞赛入门经典 习题与解答 P29
// 算法竞赛入门经典 训练指南 
// 算法竞赛入门经典 算法实现 
/*
    Dreams never shine!
    It's you that shine while chasing your dreams :)
    JAYO!!
*/
#include <iostream>
#include <cassert>
using namespace std;

int ROT[24][7] = {
{0, 3, 5, 1, 6, 2, 4}, 
{0, 2, 3, 1, 6, 4, 5}, 
{0, 4, 2, 1, 6, 5, 3}, 
{0, 5, 4, 1, 6, 3, 2}, 
{0, 3, 1, 2, 5, 6, 4}, 
{0, 6, 3, 2, 5, 4, 1}, 
{0, 4, 6, 2, 5, 1, 3}, 
{0, 1, 4, 2, 5, 3, 6}, 
{0, 1, 2, 3, 4, 5, 6}, 
{0, 5, 1, 3, 4, 6, 2}, 
{0, 6, 5, 3, 4, 2, 1}, 
{0, 2, 6, 3, 4, 1, 5}, 
{0, 6, 2, 4, 3, 5, 1}, 
{0, 5, 6, 4, 3, 1, 2}, 
{0, 1, 5, 4, 3, 2, 6}, 
{0, 2, 1, 4, 3, 6, 5}, 
{0, 3, 6, 5, 2, 1, 4}, 
{0, 1, 3, 5, 2, 4, 6}, 
{0, 4, 1, 5, 2, 6, 3}, 
{0, 6, 4, 5, 2, 3, 1}, 
{0, 3, 2, 6, 1, 5, 4}, 
{0, 5, 3, 6, 1, 4, 2}, 
{0, 4, 5, 6, 1, 2, 3}, 
{0, 2, 4, 6, 1, 3, 5}, 
};

// 用颜色所在的位置编号判断
int main() {
    string line, s1, s2, t;
    while(cin >> line) {
        assert(line.size() == 12);
        s1 = " "; // 空格和0对应
        s2.clear();
        s1 += line.substr(0, 6); s2 += line.substr(6, 6); 
        bool ans = false;
        for(int i = 0; i < 24; i++) {
            t.clear();
            for(int j = 1; j <= 6; j++) t+= s1[ROT[i][j]]; // 通过联系等价立方体的位置编号来判断（不同姿态对应同一个立方体）
            if(t == s2) { ans = true; break; }
        }
        cout << (ans ? "TRUE" : "FALSE") << endl;
    }
 	return 0;
}

知识点

立方体24种姿态

#include <cstdio>
#include <cstring>

// 标准姿态为 1 2 3 4 5 6 （依次对应正面，右面，上面，下面，左面，后面）
int left[] = {5, 1, 3, 4, 6, 2}; // 向左旋转后得到的正方体对应的标准姿态的面
// 也就是，现在的正面是未旋转时正方体的5号面，右面为未旋转前正方体的1号面...依此类推
int up[] = {3, 2, 6, 1, 5, 4}; // 向上旋转（同上）

// 通过有限次的左旋转和上旋转，可以得到所有的姿态。（6 × 4 = 24）(例如先选顶面数字有6中情况，这个时候底面也固定下来了，
// 再选侧面则有4种情况， 由于已经有标准姿态了，则其他面也都确定了)

// 按照排列T旋转姿态p（T为left和up中的一种）
void rot(int *T, int *p) {
    int q[7];
    memcpy(q, p, sizeof(q));
    for(int i = 0; i < 6; i++) p[i] = q[T[i] - 1];
    // 由q[i]依次得到未旋转前的（伪标准姿态）（或者说成是当前的标准姿态）
    // 正面，右面...经T旋转后（作为下标）得到现在的正面编号，并赋给p[i]
}

void enumerate_permutations() {
    int p0[6] = {1, 2, 3 ,4, 5, 6};
    printf("int dice24[24][7] = {\n");
    for(int i = 0; i < 6; i++) {
        int p[6];
        memcpy(p, p0, sizeof(p0));
        
        if(i == 0) { rot(left, p); rot(left, p); rot(up, p); }
        if(i == 1) { rot(left, p); rot(up, p); }
        if(i == 2) ; // 三一开始就在上
        if(i == 3) { rot(up, p); rot(up, p); }
        if(i == 4) { rot(left, p); rot(left, p); rot(left, p); rot(up, p); }
        if(i == 5) rot(up, p);
        for(int j = 0; j < 4; j++) {
            printf("{%d, %d, %d, %d, %d, %d, %d}, \n", 0, p[0], p[1], p[2], p[3], p[4], p[5]);
            rot(left, p); // 0, 1, 2 ，3次左旋转，总计为 6 × 4 = 24
        }
    }

    printf("};\n");
}

int main() {
    enumerate_permutations();
    return 0;
}

输出结果

int dice24[24][7] = {
{0, 3, 5, 1, 6, 2, 4}, 
{0, 2, 3, 1, 6, 4, 5}, 
{0, 4, 2, 1, 6, 5, 3}, 
{0, 5, 4, 1, 6, 3, 2}, 
{0, 3, 1, 2, 5, 6, 4}, 
{0, 6, 3, 2, 5, 4, 1}, 
{0, 4, 6, 2, 5, 1, 3}, 
{0, 1, 4, 2, 5, 3, 6}, 
{0, 1, 2, 3, 4, 5, 6}, 
{0, 5, 1, 3, 4, 6, 2}, 
{0, 6, 5, 3, 4, 2, 1}, 
{0, 2, 6, 3, 4, 1, 5}, 
{0, 6, 2, 4, 3, 5, 1}, 
{0, 5, 6, 4, 3, 1, 2}, 
{0, 1, 5, 4, 3, 2, 6}, 
{0, 2, 1, 4, 3, 6, 5}, 
{0, 3, 6, 5, 2, 1, 4}, 
{0, 1, 3, 5, 2, 4, 6}, 
{0, 4, 1, 5, 2, 6, 3}, 
{0, 6, 4, 5, 2, 3, 1}, 
{0, 3, 2, 6, 1, 5, 4}, 
{0, 5, 3, 6, 1, 4, 2}, 
{0, 4, 5, 6, 1, 2, 3}, 
{0, 2, 4, 6, 1, 3, 5}, 
};