gunnew의 잡설

BOJ_5373_큐빙 [Brute Brute Brute Forcing, Simulation] 본문

Algorithm

BOJ_5373_큐빙 [Brute Brute Brute Forcing, Simulation]

higunnew 2020. 1. 26. 00:34
반응형
PS 백준 소스 코드 모음 : https://github.com/kgw4073/Problem-Solving

https://www.acmicpc.net/problem/5373

 

5373번: 큐빙

문제 루빅스 큐브는 삼차원 퍼즐이다. 보통 루빅스 큐브는 3×3×3개의 작은 정육면체로 이루어져 있다. 퍼즐을 풀려면 각 면에 있는 아홉 개의 작은 정육면체의 색이 동일해야 한다. 큐브는 각 면을 양방향으로 90도 만큼 돌릴 수 있도록 만들어져 있다. 회전이 마친 이후에는, 다른 면을 돌릴 수 있다. 이렇게 큐브의 서로 다른 면을 돌리다 보면, 색을 섞을 수 있다. 이 문제에서는 루빅스 큐브가 모두 풀린 상태에서 시작한다. 윗 면은 흰색, 아랫 면은 노란

www.acmicpc.net

 세상에 이런 무식한 문제가 있었다니 놀라웠다. 설명할 방법이 없다. 그냥 코드만 첨부하겠다.

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
#include <iostream>
#include <string>
#include <algorithm>
 
using namespace std;
 
int t;
 
int map[12][9];
string s;
void init() {
    for (int j = 3; j < 6; j++) {
        for (int i = 0; i < 3; i++) {
            map[i][j] = 3;
        }
        for (int i = 6; i < 9; i++) {
            map[i][j] = 4;
        }
        for (int i = 9; i < 12; i++) {
            map[i][j] = 2;
        }
    }
    for (int i = 3; i < 6; i++) {
        for (int j = 0; j < 3; j++) {
            map[i][j] = 5;
        }
        for (int j = 3; j < 6; j++) {
            map[i][j] = 1;
        }
        for (int j = 6; j < 9; j++) {
            map[i][j] = 6;
        }
    }
}
 
void pointer_shift(int* queue[]) {
    int value[12];
    for (int i = 3; i < 12; i++) {
        value[i] = *queue[i - 3];
    }
    value[0] = *queue[9], value[1] = *queue[10], value[2] = *queue[11];
    for (int i = 0; i < 12; i++) {
        *queue[i] = value[i];
    }
}
const int starty[] = { -1, 3, 9, 0, 6, 3, 3 };
const int startx[] = { -1, 3, 3, 3, 3, 0, 6 };
void rotate(int plane, int dir) {
    int temp[3][3];
    int* queue[12] = { 0, };
    if (dir == 1) {
 
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                temp[i][j] = map[2 - j + starty[plane]][i + startx[plane]];
            }
        }
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                map[i + starty[plane]][j + startx[plane]] = temp[i][j];
            }
        }
        switch (plane) {
        case 1:
 
            queue[0] = &map[2][3], queue[1] = &map[2][4], queue[2] = &map[2][5];
            queue[3] = &map[3][6], queue[4] = &map[4][6], queue[5] = &map[5][6];
            queue[6] = &map[6][5], queue[7] = &map[6][4], queue[8] = &map[6][3];
            queue[9] = &map[5][2], queue[10] = &map[4][2], queue[11] = &map[3][2];
            break;
 
        case 2:
            queue[0] = &map[8][3], queue[1] = &map[8][4], queue[2] = &map[8][5];
            queue[3] = &map[5][8], queue[4] = &map[4][8], queue[5] = &map[3][8];
            queue[6] = &map[0][5], queue[7] = &map[0][4], queue[8] = &map[0][3];
            queue[9] = &map[3][0], queue[10] = &map[4][0], queue[11] = &map[5][0];
 
            break;
 
        case 3:
            queue[0] = &map[3][8], queue[1] = &map[3][7], queue[2] = &map[3][6];
            queue[3] = &map[3][5], queue[4] = &map[3][4], queue[5] = &map[3][3];
            queue[6] = &map[3][2], queue[7] = &map[3][1], queue[8] = &map[3][0];
            queue[9] = &map[11][3], queue[10] = &map[11][4], queue[11] = &map[11][5];
            break;
 
        case 4:
            queue[0] = &map[5][0], queue[1] = &map[5][1], queue[2] = &map[5][2];
            queue[3] = &map[5][3], queue[4] = &map[5][4], queue[5] = &map[5][5];
            queue[6] = &map[5][6], queue[7] = &map[5][7], queue[8] = &map[5][8];
            queue[9] = &map[9][5], queue[10] = &map[9][4], queue[11] = &map[9][3];
            break;
 
        case 5:
            queue[0] = &map[0][3], queue[1] = &map[1][3], queue[2] = &map[2][3];
            queue[3] = &map[3][3], queue[4] = &map[4][3], queue[5] = &map[5][3];
            queue[6] = &map[6][3], queue[7] = &map[7][3], queue[8] = &map[8][3];
            queue[9] = &map[9][3], queue[10] = &map[10][3], queue[11] = &map[11][3];
            break;
 
        case 6:
            queue[0] = &map[11][5], queue[1] = &map[10][5], queue[2] = &map[9][5];
            queue[3] = &map[8][5], queue[4] = &map[7][5], queue[5] = &map[6][5];
            queue[6] = &map[5][5], queue[7] = &map[4][5], queue[8] = &map[3][5];
            queue[9] = &map[2][5], queue[10] = &map[1][5], queue[11] = &map[0][5];
            break;
        }
    }
    else {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                temp[i][j] = map[j + starty[plane]][2 - i + startx[plane]];
            }
        }
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                map[i + starty[plane]][j + startx[plane]] = temp[i][j];
            }
        }
        switch (plane) {
        case 1:
 
            queue[11] = &map[2][3], queue[10] = &map[2][4], queue[9] = &map[2][5];
            queue[8] = &map[3][6], queue[7] = &map[4][6], queue[6] = &map[5][6];
            queue[5] = &map[6][5], queue[4] = &map[6][4], queue[3] = &map[6][3];
            queue[2] = &map[5][2], queue[1] = &map[4][2], queue[0] = &map[3][2];
            break;
 
        case 2:
            queue[11] = &map[8][3], queue[10] = &map[8][4], queue[9] = &map[8][5];
            queue[8] = &map[5][8], queue[7] = &map[4][8], queue[6] = &map[3][8];
            queue[5] = &map[0][5], queue[4] = &map[0][4], queue[3] = &map[0][3];
            queue[2] = &map[3][0], queue[1] = &map[4][0], queue[0] = &map[5][0];
 
            break;
 
        case 3:
            queue[11] = &map[3][8], queue[10] = &map[3][7], queue[9] = &map[3][6];
            queue[8] = &map[3][5], queue[7] = &map[3][4], queue[6] = &map[3][3];
            queue[5] = &map[3][2], queue[4] = &map[3][1], queue[3] = &map[3][0];
            queue[2] = &map[11][3], queue[1] = &map[11][4], queue[0] = &map[11][5];
            break;
 
        case 4:
            queue[11] = &map[5][0], queue[10] = &map[5][1], queue[9] = &map[5][2];
            queue[8] = &map[5][3], queue[7] = &map[5][4], queue[6] = &map[5][5];
            queue[5] = &map[5][6], queue[4] = &map[5][7], queue[3] = &map[5][8];
            queue[2] = &map[9][5], queue[1] = &map[9][4], queue[0] = &map[9][3];
            break;
 
        case 5:
            queue[11] = &map[0][3], queue[10] = &map[1][3], queue[9] = &map[2][3];
            queue[8] = &map[3][3], queue[7] = &map[4][3], queue[6] = &map[5][3];
            queue[5] = &map[6][3], queue[4] = &map[7][3], queue[3] = &map[8][3];
            queue[2] = &map[9][3], queue[1] = &map[10][3], queue[0] = &map[11][3];
            break;
 
        case 6:
            queue[11] = &map[11][5], queue[10] = &map[10][5], queue[9] = &map[9][5];
            queue[8] = &map[8][5], queue[7] = &map[7][5], queue[6] = &map[6][5];
            queue[5] = &map[5][5], queue[4] = &map[4][5], queue[3] = &map[3][5];
            queue[2] = &map[2][5], queue[1] = &map[1][5], queue[0] = &map[0][5];
            break;
        }
    }
    pointer_shift(queue);
}
 
int main() {
    cin.tie(0);
    cout.tie(0);
    ios_base::sync_with_stdio(false);
    cin >> t;
    while (t--) {
        init();
        int n;
        cin >> n;
        for (int i = 0; i < n; i++) {
            int plane, dir;
            cin >> s;
            switch (s[0]) {
            case 'U':
                plane = 1;
                break;
            case 'D':
                plane = 2;
                break;
            case 'F':
                plane = 4;
                break;
            case 'B':
                plane = 3;
                break;
            case 'L':
                plane = 5;
                break;
            case 'R':
                plane = 6;
                break;
            }
            if (s[1] == '-') dir = -1;
            else dir = 1;
 
            rotate(plane, dir);
        }
        for (int i = 3; i < 6; i++) {
            for (int j = 3; j < 6; j++) {
                switch (map[i][j]) {
                case 1:
                    cout << 'w';
                    break;
                case 2:
                    cout << 'y';
                    break;
                case 3:
                    cout << 'o';
                    break;
                case 4:
                    cout << 'r';
                    break;
                case 5:
                    cout << 'g';
                    break;
                case 6:
                    cout << 'b';
                    break;
                }
            }
            cout << '\n';
        }
    }
}
 cs

 

 

반응형
저작자표시

'Algorithm' 카테고리의 다른 글

BOJ_17472_다리만들기2 [Brute forcing by DFS]  (0) 2020.02.06
BOJ_17825_주사위윷놀이 [DFS by Back Tracking]  (0) 2020.01.30
BOJ_15684_사다리조작(C++) [DFS Back tracking]  (0) 2020.01.23
BOJ_12100_2048(C++) [Brute forcing by DFS]  (0) 2020.01.21
BOJ_13460_구슬탈출(C++) [BFS]  (0) 2020.01.19
'Algorithm' Related Articles more
Comments