(백준 c++)5373 큐빙

문제

루빅스 큐브는 삼차원 퍼즐이다. 보통 루빅스 큐브는 3×3×3개의 작은 정육면체로 이루어져 있다. 퍼즐을 풀려면 각 면에 있는 아홉 개의 작은 정육면체의 색이 동일해야 한다.

큐브는 각 면을 양방향으로 90도 만큼 돌릴 수 있도록 만들어져 있다. 회전이 마친 이후에는, 다른 면을 돌릴 수 있다. 이렇게 큐브의 서로 다른 면을 돌리다 보면, 색을 섞을 수 있다.

이 문제에서는 루빅스 큐브가 모두 풀린 상태에서 시작한다. 윗 면은 흰색, 아랫 면은 노란색, 앞 면은 빨간색, 뒷 면은 오렌지색, 왼쪽 면은 초록색, 오른쪽 면은 파란색이다.

루빅스 큐브를 돌린 방법이 순서대로 주어진다. 이때, 모두 돌린 다음에 가장 윗 면의 색상을 구하는 프로그램을 작성하시오.

위의 그림은 루빅스 큐브를 푼 그림이다. 왼쪽 면은 시계방향으로 조금 돌려져 있는 상태이다.

입력

첫째 줄에 테스트 케이스의 개수가 주어진다. 테스트 케이스는 최대 100개이다. 각 테스트 케이스는 다음과 같이 구성되어져 있다.

• 첫째 줄에 큐브를 돌린 횟수 n이 주어진다. (1 ≤ n ≤ 1000)
• 둘째 줄에는 큐브를 돌린 방법이 주어진다. 각 방법은 공백으로 구분되어져 있으며, 첫 번째 문자는 돌린 면이다. U: 윗 면, D: 아랫 면, F: 앞 면, B: 뒷 면, L: 왼쪽 면, R: 오른쪽 면이다. 두 번째 문자는 돌린 방향이다. +인 경우에는 시계 방향 (그 면을 바라봤을 때가 기준), -인 경우에는 반시계 방향이다.

출력

각 테스트 케이스에 대해서 큐브를 모두 돌린 후의 윗 면의 색상을 출력한다. 첫 번째 줄에는 뒷 면과 접하는 칸의 색을 출력하고, 두 번째, 세 번째 줄은 순서대로 출력하면 된다. 흰색은 w, 노란색은 y, 빨간색은 r, 오렌지색은 o, 초록색은 g, 파란색은 b.

 

 

 

이 문제는 순수 노가다를 해야한다...

그림으로 하다가 너무 헷갈려서 직접 큐브를 만들어서 했다..ㅋㅋㅋㅋ

그럼에도 불구하고 오타가 있어서 3번 틀렸는데, 오타랑 규칙만 조심하면 해결할 수 있다.

 

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

vector<vector<char>> rotateRight(vector<vector<char>> cube){
    vector<vector<char>> tmp(3, vector<char>(3, ' '));

    for(int i = 0; i < 3; i++){
        for(int j = 0; j < 3; j++){
            tmp[j][3 - i - 1] = cube[i][j];
        }
    }
    
    return tmp;
}

vector<vector<char>> rotateLeft(vector<vector<char>> cube){
    vector<vector<char>> tmp(3, vector<char>(3, ' '));

    for(int i = 0; i < 3; i++){
        for(int j = 0; j < 3; j++){
            tmp[3 - j - 1][i] = cube[i][j];
        }
    }
    
    return tmp;
}

int main(void){
    int n;
    cin >> n;

    for(int i = 0; i < n; i++){
        int t;
        vector<string> v;
        vector<vector<char>> up(3, vector<char>(3, 'w'));
        vector<vector<char>> down(3, vector<char>(3, 'y'));
        vector<vector<char>> front(3, vector<char>(3, 'r'));
        vector<vector<char>> back(3, vector<char>(3, 'o'));
        vector<vector<char>> left(3, vector<char>(3, 'g'));
        vector<vector<char>> right(3, vector<char>(3, 'b'));

        cin >> t;

        for(int j = 0; j < t; j++){
            string s;
            
            cin >> s;
            v.push_back(s);
        }

        for(int j = 0; j < v.size(); j++){
            vector<char> tmp;

            switch(v[j][0]){
                case 'U':
                    if(v[j][1] == '-'){
                        tmp = right[0];
                        right[0] = front[0];
                        front[0] = left[0];
                        left[0] = back[0];
                        back[0] = tmp;
                        up = rotateLeft(up);
                    }
                    else{
                        tmp = left[0];
                        left[0] = front[0];
                        front[0] = right[0];
                        right[0] = back[0];
                        back[0] = tmp;
                        up = rotateRight(up);
                    }
                    break;
                case 'D':
                    if(v[j][1] == '-'){
                        tmp = right[2];
                        right[2] = back[2];
                        back[2] = left[2];
                        left[2] = front[2];
                        front[2] = tmp;
                        down = rotateLeft(down);
                    }
                    else{
                        tmp = left[2];
                        left[2] = back[2];
                        back[2] = right[2];
                        right[2] = front[2];
                        front[2] = tmp;
                        down = rotateRight(down);
                    }
                    break;
                case 'F':
                    if(v[j][1] == '-'){
                        for(int k = 0; k < 3; k++){
                            tmp.push_back(right[k][0]);
                        }

                        for(int k = 0; k < 3; k++){
                            right[k][0] = down[0][2 - k];
                            down[0][2 - k] = left[2 - k][2];
                            left[2 - k][2] = up[2][k];
                            up[2][k] = tmp[k];
                        }
                        front = rotateLeft(front);
                    }
                    else{
                        for(int k = 0; k < 3; k++){
                            tmp.push_back(left[k][2]);
                        }
                        
                        for(int k = 0; k < 3; k++){
                            left[k][2] = down[0][k];
                            down[0][k] = right[2 - k][0];
                            right[2 - k][0] = up[2][2 - k];
                            up[2][2 - k] = tmp[k];
                        }
                        front = rotateRight(front);
                    }
                    break;
                case 'B':
                    if(v[j][1] == '-'){
                        for(int k = 0; k < 3; k++){
                            tmp.push_back(left[k][0]);
                        }

                        for(int k = 0; k < 3; k++){
                            left[k][0] = down[2][k];
                            down[2][k] = right[2 - k][2];
                            right[2 - k][2] = up[0][2 - k];
                            up[0][2 - k] = tmp[k];
                        }
                        back = rotateLeft(back);
                    }
                    else{
                        for(int k = 0; k < 3; k++){
                            tmp.push_back(right[k][2]);
                        }

                        for(int k = 0; k < 3; k++){
                            right[k][2] = down[2][2 - k];
                            down[2][2 - k] = left[2 - k][0];
                            left[2 - k][0] = up[0][k];
                            up[0][k] = tmp[k];
                        }
                        back = rotateRight(back);
                    }
                    break;
                case 'L':
                    if(v[j][1] == '-'){
                        for(int k = 0; k < 3; k++){
                            tmp.push_back(front[k][0]);
                        }

                        for(int k = 0; k < 3; k++){
                            front[k][0] = down[k][0];
                            down[k][0] = back[2 - k][2];
                            back[2 - k][2] = up[k][0];
                            up[k][0] = tmp[k];
                        }
                        left = rotateLeft(left);
                    }
                    else{
                        for(int k = 0; k < 3; k++){
                            tmp.push_back(back[k][2]);
                        }

                        for(int k = 0; k < 3; k++){
                            back[k][2] = down[2 - k][0];
                            down[2 - k][0] = front[2 - k][0];
                            front[2 - k][0] = up[2 - k][0];
                            up[2 - k][0] = tmp[k];
                        }
                        left = rotateRight(left);
                    }
                    break;
                case 'R':
                    if(v[j][1] == '-'){
                        for(int k = 0; k < 3; k++){
                            tmp.push_back(back[k][0]);
                        }

                        for(int k = 0; k < 3; k++){
                            back[k][0] = down[2 - k][2];
                            down[2 - k][2] = front[2 - k][2];
                            front[2 - k][2] = up[2 - k][2];
                            up[2 - k][2] = tmp[k];
                        }
                        right = rotateLeft(right);
                    }
                    else{
                        for(int k = 0; k < 3; k++){
                            tmp.push_back(front[k][2]);
                        }

                        for(int k = 0; k < 3; k++){
                            front[k][2] = down[k][2];
                            down[k][2] = back[2 - k][0];
                            back[2 - k][0] = up[k][2];
                            up[k][2] = tmp[k];
                        }
                        right = rotateRight(right);
                    }
                    break;
            }
        }

        for(int j = 0; j < 3; j++){
            for(int k = 0; k < 3; k++){
                cout << up[j][k];
            }
            cout << endl;
        }
    }
    
    return 0;
}