[백준 5373][구현] 큐빙

세상 매우 귀찮게 구현해야하는 문제를 이렇게 짧은 지문만으로 제시하는 것도 출제자의 역량이라 생각한다.

문제 설명

문제 링크

삼성 코딩테스트 대비 문제집에 있는 문제로, 문제 자체는 간단하다. 우리가 흔히 아는 3*3*3의 정육면체 큐브가 주어지고, 이 큐브를 주어진 방법대로 돌린다. 예를 들어, U+는 윗 면을 시계 방향으로 돌린다.

 

 

문제 풀이

아마 이 문제를 푸는 사람 중 절대 다수는 삼성 코테 준비하는 사람들일 것이다. 사실, 삼성 코테, 즉 어드밴스급은 최적화가 그닥 필요 없다. 그냥 문제에서 주어진대로. 문제를 함수 단위로 쪼개서 풀면 된다. 따라서 나름 객체지향적 사고가 필요하다.

 

본인은 (테스트케이스가 있는 문제인 만큼) 초기화 함수를 만들었다. 초기 각 면의 색상이 정해져 있으므로 그 색깔로 큐브를 초기화한다. 큐브는 [6][3][3]의 char형 배열로 표현했는데, 첫 번째 칸은 큐브의 각 면, [3][3]은 그 면의 각 색깔을 표현했다. 이는 윗면 아랫면 등 헷갈릴 수 있으므로 종이에 그리면서 풀면 덜 헷갈린다.

 

그리고 큐브를 돌리는 모든 경우의 수에 대한 함수를 만들어주면 된다!  (...)

간단하게 얘기하자면, 어떤 명령에 의해 돌렸을 때, 예를 들어 U+ 명령을 받아 윗 면을 시계방향으로 돌릴 때 큐브 전체에서 총 20칸의 색상이 바뀐다. 이를 {{이전 칸}, {이전 칸에 들어오게 될 칸}} 형식을 배열로 쌓아 모두 적용하도록 하였다. 물론 변환 중 큐브 전체의 데이터는 아토믹해야하므로 (swap함수때 tmp를 만들듯이) 기존 상태를 저장하여 그 상태로부터 각 칸의 색상을 참조하였다.

 

자세한 내용은 코드를 참조하자.

 

 

코드

#include <iostream>
#include <string>
using namespace std;

// 위, 앞, 아래, 뒤, 좌, 우
char cube[6][3][3];
char cube_color[6] = {'w', 'r', 'y', 'o', 'g', 'b'};

void cube_init()
{
    for (int i = 0; i < 6; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            for (int k = 0; k < 3; k++)
            {
                cube[i][j][k] = cube_color[i];
            }
        }
    }
}

void tmp_cube_create(char tmp_cube[][3][3])
{
    for (int i = 0; i < 6; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            for (int k = 0; k < 3; k++)
            {
                tmp_cube[i][j][k] = cube[i][j][k];
            }
        }
    }
}

void U(bool is_plus)
{
    char tmp_cube[6][3][3];
    tmp_cube_create(tmp_cube);

    int t[][2][3] = {
        {{0, 0, 0}, {0, 2, 0}},
        {{0, 0, 1}, {0, 1, 0}},
        {{0, 0, 2}, {0, 0, 0}},
        {{0, 1, 0}, {0, 2, 1}},
        {{0, 1, 2}, {0, 0, 1}},
        {{0, 2, 0}, {0, 2, 2}},
        {{0, 2, 1}, {0, 1, 2}},
        {{0, 2, 2}, {0, 0, 2}},
        {{1, 0, 0}, {5, 0, 0}},
        {{1, 0, 1}, {5, 0, 1}},
        {{1, 0, 2}, {5, 0, 2}},
        {{4, 0, 0}, {1, 0, 0}},
        {{4, 0, 1}, {1, 0, 1}},
        {{4, 0, 2}, {1, 0, 2}},
        {{3, 0, 0}, {4, 0, 0}},
        {{3, 0, 1}, {4, 0, 1}},
        {{3, 0, 2}, {4, 0, 2}},
        {{5, 0, 0}, {3, 0, 0}},
        {{5, 0, 1}, {3, 0, 1}},
        {{5, 0, 2}, {3, 0, 2}}};

    for (int i = 0; i < 20; i++)
    {
        if (is_plus)
            cube[t[i][0][0]][t[i][0][1]][t[i][0][2]] = tmp_cube[t[i][1][0]][t[i][1][1]][t[i][1][2]];
        else
            cube[t[i][1][0]][t[i][1][1]][t[i][1][2]] = tmp_cube[t[i][0][0]][t[i][0][1]][t[i][0][2]];
    }
}

void D(bool is_plus)
{
    char tmp_cube[6][3][3];
    tmp_cube_create(tmp_cube);

    int t[][2][3] = {
        {{2, 0, 0}, {2, 2, 0}},
        {{2, 0, 1}, {2, 1, 0}},
        {{2, 0, 2}, {2, 0, 0}},
        {{2, 1, 2}, {2, 0, 1}},
        {{2, 2, 2}, {2, 0, 2}},
        {{2, 2, 1}, {2, 1, 2}},
        {{2, 2, 0}, {2, 2, 2}},
        {{2, 1, 0}, {2, 2, 1}},
        {{1, 2, 0}, {4, 2, 0}},
        {{1, 2, 1}, {4, 2, 1}},
        {{1, 2, 2}, {4, 2, 2}},
        {{5, 2, 0}, {1, 2, 0}},
        {{5, 2, 1}, {1, 2, 1}},
        {{5, 2, 2}, {1, 2, 2}},
        {{3, 2, 0}, {5, 2, 0}},
        {{3, 2, 1}, {5, 2, 1}},
        {{3, 2, 2}, {5, 2, 2}},
        {{4, 2, 0}, {3, 2, 0}},
        {{4, 2, 1}, {3, 2, 1}},
        {{4, 2, 2}, {3, 2, 2}}};

    for (int i = 0; i < 20; i++)
    {
        if (is_plus)
            cube[t[i][0][0]][t[i][0][1]][t[i][0][2]] = tmp_cube[t[i][1][0]][t[i][1][1]][t[i][1][2]];
        else
            cube[t[i][1][0]][t[i][1][1]][t[i][1][2]] = tmp_cube[t[i][0][0]][t[i][0][1]][t[i][0][2]];
    }
}

void F(bool is_plus)
{
    char tmp_cube[6][3][3];
    tmp_cube_create(tmp_cube);

    int t[][2][3] = {
        {{1, 0, 0}, {1, 2, 0}},
        {{1, 0, 1}, {1, 1, 0}},
        {{1, 0, 2}, {1, 0, 0}},
        {{1, 1, 2}, {1, 0, 1}},
        {{1, 2, 2}, {1, 0, 2}},
        {{1, 2, 1}, {1, 1, 2}},
        {{1, 2, 0}, {1, 2, 2}},
        {{1, 1, 0}, {1, 2, 1}},
        {{0, 2, 0}, {4, 2, 2}},
        {{0, 2, 1}, {4, 1, 2}},
        {{0, 2, 2}, {4, 0, 2}},
        {{5, 0, 0}, {0, 2, 0}},
        {{5, 1, 0}, {0, 2, 1}},
        {{5, 2, 0}, {0, 2, 2}},
        {{2, 0, 0}, {5, 2, 0}},
        {{2, 0, 1}, {5, 1, 0}},
        {{2, 0, 2}, {5, 0, 0}},
        {{4, 0, 2}, {2, 0, 0}},
        {{4, 1, 2}, {2, 0, 1}},
        {{4, 2, 2}, {2, 0, 2}}};

    for (int i = 0; i < 20; i++)
    {
        if (is_plus)
            cube[t[i][0][0]][t[i][0][1]][t[i][0][2]] = tmp_cube[t[i][1][0]][t[i][1][1]][t[i][1][2]];
        else
            cube[t[i][1][0]][t[i][1][1]][t[i][1][2]] = tmp_cube[t[i][0][0]][t[i][0][1]][t[i][0][2]];
    }
}

void B(bool is_plus)
{
    char tmp_cube[6][3][3];
    tmp_cube_create(tmp_cube);

    int t[][2][3] = {
        {{3, 0, 0}, {3, 2, 0}},
        {{3, 0, 1}, {3, 1, 0}},
        {{3, 0, 2}, {3, 0, 0}},
        {{3, 1, 2}, {3, 0, 1}},
        {{3, 2, 2}, {3, 0, 2}},
        {{3, 2, 1}, {3, 1, 2}},
        {{3, 2, 0}, {3, 2, 2}},
        {{3, 1, 0}, {3, 2, 1}},
        {{0, 0, 2}, {5, 2, 2}},
        {{0, 0, 1}, {5, 1, 2}},
        {{0, 0, 0}, {5, 0, 2}},
        {{4, 0, 0}, {0, 0, 2}},
        {{4, 1, 0}, {0, 0, 1}},
        {{4, 2, 0}, {0, 0, 0}},
        {{2, 2, 0}, {4, 0, 0}},
        {{2, 2, 1}, {4, 1, 0}},
        {{2, 2, 2}, {4, 2, 0}},
        {{5, 2, 2}, {2, 2, 0}},
        {{5, 1, 2}, {2, 2, 1}},
        {{5, 0, 2}, {2, 2, 2}}};

    for (int i = 0; i < 20; i++)
    {
        if (is_plus)
            cube[t[i][0][0]][t[i][0][1]][t[i][0][2]] = tmp_cube[t[i][1][0]][t[i][1][1]][t[i][1][2]];
        else
            cube[t[i][1][0]][t[i][1][1]][t[i][1][2]] = tmp_cube[t[i][0][0]][t[i][0][1]][t[i][0][2]];
    }
}

void L(bool is_plus)
{
    char tmp_cube[6][3][3];
    tmp_cube_create(tmp_cube);

    int t[][2][3] = {
        {{4, 0, 0}, {4, 2, 0}},
        {{4, 0, 1}, {4, 1, 0}},
        {{4, 0, 2}, {4, 0, 0}},
        {{4, 1, 2}, {4, 0, 1}},
        {{4, 2, 2}, {4, 0, 2}},
        {{4, 2, 1}, {4, 1, 2}},
        {{4, 2, 0}, {4, 2, 2}},
        {{4, 1, 0}, {4, 2, 1}},
        {{0, 0, 0}, {3, 2, 2}},
        {{0, 1, 0}, {3, 1, 2}},
        {{0, 2, 0}, {3, 0, 2}},
        {{1, 0, 0}, {0, 0, 0}},
        {{1, 1, 0}, {0, 1, 0}},
        {{1, 2, 0}, {0, 2, 0}},
        {{2, 0, 0}, {1, 0, 0}},
        {{2, 1, 0}, {1, 1, 0}},
        {{2, 2, 0}, {1, 2, 0}},
        {{3, 2, 2}, {2, 0, 0}},
        {{3, 1, 2}, {2, 1, 0}},
        {{3, 0, 2}, {2, 2, 0}}};

    for (int i = 0; i < 20; i++)
    {
        if (is_plus)
            cube[t[i][0][0]][t[i][0][1]][t[i][0][2]] = tmp_cube[t[i][1][0]][t[i][1][1]][t[i][1][2]];
        else
            cube[t[i][1][0]][t[i][1][1]][t[i][1][2]] = tmp_cube[t[i][0][0]][t[i][0][1]][t[i][0][2]];
    }
}

void R(bool is_plus)
{
    char tmp_cube[6][3][3];
    tmp_cube_create(tmp_cube);

    int t[][2][3] = {
        {{5, 0, 0}, {5, 2, 0}},
        {{5, 0, 1}, {5, 1, 0}},
        {{5, 0, 2}, {5, 0, 0}},
        {{5, 1, 2}, {5, 0, 1}},
        {{5, 2, 2}, {5, 0, 2}},
        {{5, 2, 1}, {5, 1, 2}},
        {{5, 2, 0}, {5, 2, 2}},
        {{5, 1, 0}, {5, 2, 1}},
        {{0, 2, 2}, {1, 2, 2}},
        {{0, 1, 2}, {1, 1, 2}},
        {{0, 0, 2}, {1, 0, 2}},
        {{3, 0, 0}, {0, 2, 2}},
        {{3, 1, 0}, {0, 1, 2}},
        {{3, 2, 0}, {0, 0, 2}},
        {{2, 2, 2}, {3, 0, 0}},
        {{2, 1, 2}, {3, 1, 0}},
        {{2, 0, 2}, {3, 2, 0}},
        {{1, 2, 2}, {2, 2, 2}},
        {{1, 1, 2}, {2, 1, 2}},
        {{1, 0, 2}, {2, 0, 2}}};

    for (int i = 0; i < 20; i++)
    {
        if (is_plus)
            cube[t[i][0][0]][t[i][0][1]][t[i][0][2]] = tmp_cube[t[i][1][0]][t[i][1][1]][t[i][1][2]];
        else
            cube[t[i][1][0]][t[i][1][1]][t[i][1][2]] = tmp_cube[t[i][0][0]][t[i][0][1]][t[i][0][2]];
    }
}

void print_cube()
{
    for (int i = 0; i < 3; i++)
    {
        cout << "    ";
        for (int j = 0; j < 3; j++)
        {
            cout << cube[0][i][j];
        }
        cout << "\n";
    }
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            cout << cube[4][i][j];
        }
        cout << ' ';
        for (int j = 0; j < 3; j++)
        {
            cout << cube[1][i][j];
        }
        cout << ' ';
        for (int j = 0; j < 3; j++)
        {
            cout << cube[5][i][j];
        }
        cout << "\n";
    }

    for (int i = 0; i < 3; i++)
    {
        cout << "    ";
        for (int j = 0; j < 3; j++)
        {
            cout << cube[2][i][j];
        }
        cout << "\n";
    }
    for (int i = 0; i < 3; i++)
    {
        cout << "    ";
        for (int j = 0; j < 3; j++)
        {
            cout << cube[3][i][j];
        }
        cout << "\n";
    }
    cout << '\n';
}

int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        cube_init();
        int n;
        cin >> n;
        while (n--)
        {
            string s;
            cin >> s;
            if (s[0] == 'U')
                U(s[1] == '+');
            if (s[0] == 'D')
                D(s[1] == '+');
            if (s[0] == 'F')
                F(s[1] == '+');
            if (s[0] == 'B')
                B(s[1] == '+');
            if (s[0] == 'L')
                L(s[1] == '+');
            if (s[0] == 'R')
                R(s[1] == '+');
        }
        for (int i = 0; i < 3; i++)
        {
            for (int j = 0; j < 3; j++)
            {
                cout << cube[0][i][j];
            }
            cout << '\n';
        }
    }
}