본문 바로가기
Computer Science

큐브

by OKOK 2020. 1. 7.

Problem D : 큐브

 

제한시간: 1000 ms    메모리제한: 0 MB

 

 

현성이는 3 * 3의 면으로 구성된 정육면체 모양의 큐브를 각 면이 같은 색깔이 되도록 힘들게 맞추어 놓았다.

책상위에 올려놓고 잠깐 마트에 가서 아이스크림을 사먹고 왔더니 그 사이 동생이 큐브를 가지고 놀고 있다.
힘들게 맞추어 놓았는데 동생이 다시 제멋대로 돌려 놓는 바람에 다시 맞춰야 한다로 생각하니 조금아까 먹은 아이스크림이 올라올 거 같았다.

동생에게 몇번을 돌렸다고 물었더니 정확하게 10번을 돌렸다고 한다.

현성이를 위해서 돌리는 횟수를 최소로 하여 원래의 상태로 맞출수 있도록 프로그램을 작성해 주도록 하자.

 

//-------------main.cpp-------------

#define _CRT_SECURE_NO_WARNINGS // Ignore build errors when using unsafe functions in Visual Studio.

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

#define SIZE        3

#define FRONT       0

#define BACK        1

#define UP          2

#define DOWN        3

#define LEFT        4

#define RIGHT       5

extern void run(int cube[6][SIZE][SIZE]);

static int Cube[6][SIZE][SIZE];

static int call_count = 0;

void rotate(int face, bool ccw);

int main(void)

{

    setbuf(stdout, NULL);

    srand(3); // The seed will be changed.

    int TC = 100;

    double total_count = 0.0;

    double RunTime = 0.0;

    for (int tc = 1; tc <= TC; ++tc)

    {

        int arr[6][SIZE][SIZE];

        register int face, row, col;

        for (face = 0; face < 6; ++face)

            for (row = 0; row < SIZE; ++row)

                for (col = 0; col < SIZE; ++col)

                    Cube[face][row][col] = face;

        for (register int cnt = 0; cnt < 10; ++cnt)

        {

            int s = rand() % 6;

            bool c = rand() % 2 ? true : false;

            rotate(s, c);

        }

        for (face = 0; face < 6; ++face)

            for (row = 0; row < SIZE; ++row)

                for (col = 0; col < SIZE; ++col)

                    arr[face][row][col] = Cube[face][row][col];

        call_count = 0;

        time_t start = clock();

        run(arr);

        RunTime += (clock() - start) / (CLOCKS_PER_SEC / 1000);

        for (face = 0; face < 6; ++face)

            for (row = 0; row < SIZE; ++row)

                for (col = 0; col < SIZE; ++col)

                    if (Cube[face][row][col] != face)

                        call_count += 1000;

        printf("#%d %d\n", tc, call_count);

        total_count += call_count;

    }

 

    printf("SCORE: %.4lf\n", total_count + RunTime / 10000);

    return 0;

}

void rotate(int face, bool ccw)

{

    int preCube[6][SIZE][SIZE];

    ++call_count;

    register int s, i, j;

    for (s = 0; s < 6; ++s)

        for (i = 0; i < SIZE; ++i)

            for (j = 0; j < SIZE; ++j)

                preCube[s][i][j] = Cube[s][i][j];

    if (ccw)

    {

        for (i = 0; i < SIZE; ++i)

            for (j = 0; j < SIZE; ++j)

                Cube[face][j][SIZE - 1 - i] = preCube[face][i][j];

    }

    else

    {

        for (i = 0; i < SIZE; ++i)

            for (j = 0; j < SIZE; ++j)

                Cube[face][SIZE - 1 - j][i] = preCube[face][i][j];

    }

    switch (face)

    {

    case FRONT:

        if (ccw)

        {

            Cube[UP][2][0] = preCube[LEFT][2][2];

            Cube[UP][2][1] = preCube[LEFT][1][2];

            Cube[UP][2][2] = preCube[LEFT][0][2];

            Cube[RIGHT][0][0] = preCube[UP][2][0];

            Cube[RIGHT][1][0] = preCube[UP][2][1];

            Cube[RIGHT][2][0] = preCube[UP][2][2];

            Cube[DOWN][0][0] = preCube[RIGHT][2][0];

            Cube[DOWN][0][1] = preCube[RIGHT][1][0];

            Cube[DOWN][0][2] = preCube[RIGHT][0][0];

            Cube[LEFT][0][2] = preCube[DOWN][0][0];

            Cube[LEFT][1][2] = preCube[DOWN][0][1];

            Cube[LEFT][2][2] = preCube[DOWN][0][2];

        }

        else

        {

            Cube[UP][2][0] = preCube[RIGHT][0][0];

            Cube[UP][2][1] = preCube[RIGHT][1][0];

            Cube[UP][2][2] = preCube[RIGHT][2][0];

            Cube[RIGHT][0][0] = preCube[DOWN][0][2];

            Cube[RIGHT][1][0] = preCube[DOWN][0][1];

            Cube[RIGHT][2][0] = preCube[DOWN][0][0];

            Cube[DOWN][0][0] = preCube[LEFT][0][2];

            Cube[DOWN][0][1] = preCube[LEFT][1][2];

            Cube[DOWN][0][2] = preCube[LEFT][2][2];

            Cube[LEFT][0][2] = preCube[UP][2][2];

            Cube[LEFT][1][2] = preCube[UP][2][1];

            Cube[LEFT][2][2] = preCube[UP][2][0];

        }

        break;

    case BACK:

        if (ccw)

        {

            Cube[UP][0][2] = preCube[RIGHT][2][2];

            Cube[UP][0][1] = preCube[RIGHT][1][2];

            Cube[UP][0][0] = preCube[RIGHT][0][2];

            Cube[LEFT][0][0] = preCube[UP][0][2];

            Cube[LEFT][1][0] = preCube[UP][0][1];

            Cube[LEFT][2][0] = preCube[UP][0][0];

            Cube[DOWN][2][2] = preCube[LEFT][2][0];

            Cube[DOWN][2][1] = preCube[LEFT][1][0];

            Cube[DOWN][2][0] = preCube[LEFT][0][0];

            Cube[RIGHT][0][2] = preCube[DOWN][2][2];

            Cube[RIGHT][1][2] = preCube[DOWN][2][1];

            Cube[RIGHT][2][2] = preCube[DOWN][2][0];

        }

        else

        {

            Cube[UP][0][2] = preCube[LEFT][0][0];

            Cube[UP][0][1] = preCube[LEFT][1][0];

            Cube[UP][0][0] = preCube[LEFT][2][0];

            Cube[LEFT][0][0] = preCube[DOWN][2][0];

            Cube[LEFT][1][0] = preCube[DOWN][2][1];

            Cube[LEFT][2][0] = preCube[DOWN][2][2];

            Cube[DOWN][2][2] = preCube[RIGHT][0][2];

            Cube[DOWN][2][1] = preCube[RIGHT][1][2];

            Cube[DOWN][2][0] = preCube[RIGHT][2][2];

            Cube[RIGHT][0][2] = preCube[UP][0][0];

            Cube[RIGHT][1][2] = preCube[UP][0][1];

            Cube[RIGHT][2][2] = preCube[UP][0][2];

        }

        break;

    case UP:

        if (ccw)

        {

            Cube[BACK][0][2] = preCube[LEFT][0][2];

            Cube[BACK][0][1] = preCube[LEFT][0][1];

            Cube[BACK][0][0] = preCube[LEFT][0][0];

            Cube[RIGHT][0][2] = preCube[BACK][0][2];

            Cube[RIGHT][0][1] = preCube[BACK][0][1];

            Cube[RIGHT][0][0] = preCube[BACK][0][0];

            Cube[FRONT][0][0] = preCube[RIGHT][0][0];

            Cube[FRONT][0][1] = preCube[RIGHT][0][1];

            Cube[FRONT][0][2] = preCube[RIGHT][0][2];

            Cube[LEFT][0][0] = preCube[FRONT][0][0];

            Cube[LEFT][0][1] = preCube[FRONT][0][1];

            Cube[LEFT][0][2] = preCube[FRONT][0][2];

        }

        else

        {

            Cube[BACK][0][2] = preCube[RIGHT][0][2];

            Cube[BACK][0][1] = preCube[RIGHT][0][1];

            Cube[BACK][0][0] = preCube[RIGHT][0][0];

            Cube[RIGHT][0][2] = preCube[FRONT][0][2];

            Cube[RIGHT][0][1] = preCube[FRONT][0][1];

            Cube[RIGHT][0][0] = preCube[FRONT][0][0];

            Cube[FRONT][0][0] = preCube[LEFT][0][0];

            Cube[FRONT][0][1] = preCube[LEFT][0][1];

            Cube[FRONT][0][2] = preCube[LEFT][0][2];

            Cube[LEFT][0][0] = preCube[BACK][0][0];

            Cube[LEFT][0][1] = preCube[BACK][0][1];

            Cube[LEFT][0][2] = preCube[BACK][0][2];

        }

        break;

    case DOWN:

        if (ccw)

        {

            Cube[FRONT][2][0] = preCube[LEFT][2][0];

            Cube[FRONT][2][1] = preCube[LEFT][2][1];

            Cube[FRONT][2][2] = preCube[LEFT][2][2];

            Cube[RIGHT][2][0] = preCube[FRONT][2][0];

            Cube[RIGHT][2][1] = preCube[FRONT][2][1];

            Cube[RIGHT][2][2] = preCube[FRONT][2][2];

            Cube[BACK][2][2] = preCube[RIGHT][2][2];

            Cube[BACK][2][1] = preCube[RIGHT][2][1];

            Cube[BACK][2][0] = preCube[RIGHT][2][0];

            Cube[LEFT][2][2] = preCube[BACK][2][2];

            Cube[LEFT][2][1] = preCube[BACK][2][1];

            Cube[LEFT][2][0] = preCube[BACK][2][0];

        }

        else

        {

            Cube[FRONT][2][0] = preCube[RIGHT][2][0];

            Cube[FRONT][2][1] = preCube[RIGHT][2][1];

            Cube[FRONT][2][2] = preCube[RIGHT][2][2];

            Cube[RIGHT][2][0] = preCube[BACK][2][0];

            Cube[RIGHT][2][1] = preCube[BACK][2][1];

            Cube[RIGHT][2][2] = preCube[BACK][2][2];

            Cube[BACK][2][2] = preCube[LEFT][2][2];

            Cube[BACK][2][1] = preCube[LEFT][2][1];

            Cube[BACK][2][0] = preCube[LEFT][2][0];

            Cube[LEFT][2][2] = preCube[FRONT][2][2];

            Cube[LEFT][2][1] = preCube[FRONT][2][1];

            Cube[LEFT][2][0] = preCube[FRONT][2][0];

        }

        break;

    case LEFT:

        if (ccw)

        {

            Cube[UP][0][0] = preCube[BACK][2][2];

            Cube[UP][1][0] = preCube[BACK][1][2];

            Cube[UP][2][0] = preCube[BACK][0][2];

            Cube[FRONT][0][0] = preCube[UP][0][0];

            Cube[FRONT][1][0] = preCube[UP][1][0];

            Cube[FRONT][2][0] = preCube[UP][2][0];

            Cube[DOWN][2][0] = preCube[FRONT][2][0];

            Cube[DOWN][1][0] = preCube[FRONT][1][0];

            Cube[DOWN][0][0] = preCube[FRONT][0][0];

            Cube[BACK][0][2] = preCube[DOWN][2][0];

            Cube[BACK][1][2] = preCube[DOWN][1][0];

            Cube[BACK][2][2] = preCube[DOWN][0][0];

        }

        else

        {

            Cube[UP][0][0] = preCube[FRONT][0][0];

            Cube[UP][1][0] = preCube[FRONT][1][0];

            Cube[UP][2][0] = preCube[FRONT][2][0];

            Cube[FRONT][0][0] = preCube[DOWN][0][0];

            Cube[FRONT][1][0] = preCube[DOWN][1][0];

            Cube[FRONT][2][0] = preCube[DOWN][2][0];

            Cube[DOWN][2][0] = preCube[BACK][0][2];

            Cube[DOWN][1][0] = preCube[BACK][1][2];

            Cube[DOWN][0][0] = preCube[BACK][2][2];

            Cube[BACK][0][2] = preCube[UP][2][0];

            Cube[BACK][1][2] = preCube[UP][1][0];

            Cube[BACK][2][2] = preCube[UP][0][0];

        }

        break;

    case RIGHT:

        if (ccw)

        {

            Cube[UP][2][2] = preCube[FRONT][2][2];

            Cube[UP][1][2] = preCube[FRONT][1][2];

            Cube[UP][0][2] = preCube[FRONT][0][2];

            Cube[BACK][0][0] = preCube[UP][2][2];

            Cube[BACK][1][0] = preCube[UP][1][2];

            Cube[BACK][2][0] = preCube[UP][0][2];

            Cube[DOWN][0][2] = preCube[BACK][2][0];

            Cube[DOWN][1][2] = preCube[BACK][1][0];

            Cube[DOWN][2][2] = preCube[BACK][0][0];

            Cube[FRONT][0][2] = preCube[DOWN][0][2];

            Cube[FRONT][1][2] = preCube[DOWN][1][2];

            Cube[FRONT][2][2] = preCube[DOWN][2][2];

        }

        else

        {

            Cube[UP][2][2] = preCube[BACK][0][0];

            Cube[UP][1][2] = preCube[BACK][1][0];

            Cube[UP][0][2] = preCube[BACK][2][0];

            Cube[BACK][0][0] = preCube[DOWN][2][2];

            Cube[BACK][1][0] = preCube[DOWN][1][2];

            Cube[BACK][2][0] = preCube[DOWN][0][2];

            Cube[DOWN][0][2] = preCube[FRONT][0][2];

            Cube[DOWN][1][2] = preCube[FRONT][1][2];

            Cube[DOWN][2][2] = preCube[FRONT][2][2];

            Cube[FRONT][0][2] = preCube[UP][0][2];

            Cube[FRONT][1][2] = preCube[UP][1][2];

            Cube[FRONT][2][2] = preCube[UP][2][2];

        }

        break;

    }

 

//-------------user.cpp-------------

extern void rotate(int face, bool ccw);

void run(int cube[6][3][3])

{

 

}​ 

 

extern void rotate(int face, bool ccw);
void myrotate(int Cube[6][3][3], int face, bool ccw);

const int HN = (1 << 20); // 2^20 안에 들어가는지 확인 

struct data {
	int rcnt, cu[6], face[6], cw[6];
	data *next;
	int same(int _cu[]) {
		for (int i = 0; i < 6; i++) if (cu[i] != _cu[i]) return 0;
		return 1;
	}
	data *myAlloc(int _rcnt, int _cu[], int _face[], int _cw[], data *_next) {
		rcnt = _rcnt, next = _next;
		for (int i = 0; i < 6; i++) cu[i] = _cu[i];
		for (int i = 0; i < rcnt; i++) face[i] = _face[i], cw[i] = _cw[i];
		return this;
	}
} *hash[HN], buf[300000], ans1, ans2; // hash 이렇게 가져다 쓰고, buf 이렇게 사용
int bn, flag, face[6], cw[6];

int hash_key(int cu[]) {
	int key = 0;
	for (int i = 0; i < 6; i++) key = key + cu[i] * (i + 1);
	return key % HN;
}

int push(int step, int cu[])
{
	int key = hash_key(cu);
	for (data *p = hash[key]; p != 0; p = p->next) {
		if (p->same(cu)) {
			if (p->rcnt <= step) return 1;
			p->rcnt = step;
			for (int i = 0; i < step; i++) p->face[i] = face[i], p->cw[i] = cw[i];
			return 0;
		}
	}
	hash[key] = buf[bn++].myAlloc(step, cu, face, cw, hash[key]);
	return 0;
}

int search(int step, int cu[])
{
	int key = hash_key(cu);
	for (data *p = hash[key]; p != 0; p = p->next) {
		if (p->same(cu)) {
			ans1 = *p;
			ans2.rcnt = step;
			for (int i = 0; i < step; i++) ans2.face[i] = face[i], ans2.cw[i] = cw[i];
			return 1;
		}
	}
	return 0;
}

void cal(int cube[6][3][3], int cu[]) {
	for (int k = 0; k < 6; k++) {
		cu[k] = 0;
		for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++)
			cu[k] = cu[k] * 6 + cube[k][i][j]; // 하나의 큐브에 대해 일종의 해시값을 만들음
	}
}

void dfs1(int cube[6][3][3], int step)
{
	int i, j, cu[6] = { 0 }; // 해시값 저장
	cal(cube, cu);
	if (push(step, cu)) return;
	if (step >= 5) return;
	for (i = 0; i < 6; i++) {
		face[step] = i;
		for (j = 0; j < 2; j++) {
			cw[step] = j;
			myrotate(cube, i, j);
			dfs1(cube, step + 1);
			myrotate(cube, i, 1 - j);
		}
	}
}

void dfs2(int cube[6][3][3], int step)
{
	int i, j, cu[6] = { 0 };
	cal(cube, cu);
	if (search(step, cu)) return;
	//if (step >= 5) return;
	if (ans1.rcnt + ans2.rcnt - 2 <= step + 5) return;
	for (i = 0; i < 6; i++) {
		face[step] = i;
		for (j = 0; j < 2; j++) {
			cw[step] = j;
			myrotate(cube, i, j);
			dfs2(cube, step + 1);
			myrotate(cube, i, 1 - j);
		}
	}
}

void run(int cube[6][3][3])
{
	int i, j, k;
	if (flag == 0) {
		flag = 1;
		int mycube[6][3][3];
		for (k = 0; k < 6; k++) {
			for (i = 0; i < 3; i++) for (j = 0; j < 3; j++) mycube[k][i][j] = k;
		}
		dfs1(mycube, 0);
	}
	ans1.rcnt = ans2.rcnt = 6;
	dfs2(cube, 0);
	for (i = 0; i < ans2.rcnt; i++) rotate(ans2.face[i], ans2.cw[i]);
	for (i = ans1.rcnt - 1; i >= 0; i--) rotate(ans1.face[i], 1 - ans1.cw[i]);
}


















#define SIZE        3
#define FRONT       0
#define BACK        1
#define UP          2
#define DOWN        3
#define LEFT        4
#define RIGHT       5

void myrotate(int Cube[6][3][3], int face, bool ccw)
{
	int preCube[6][SIZE][SIZE];

	register int s, i, j;
	for (s = 0; s < 6; ++s)
		for (i = 0; i < SIZE; ++i)
			for (j = 0; j < SIZE; ++j)
				preCube[s][i][j] = Cube[s][i][j];

	if (ccw)
	{
		for (i = 0; i < SIZE; ++i)
			for (j = 0; j < SIZE; ++j)
				Cube[face][j][SIZE - 1 - i] = preCube[face][i][j];
	}
	else
	{
		for (i = 0; i < SIZE; ++i)
			for (j = 0; j < SIZE; ++j)
				Cube[face][SIZE - 1 - j][i] = preCube[face][i][j];
	}

	switch (face)
	{
	case FRONT:
		if (ccw)
		{
			Cube[UP][2][0] = preCube[LEFT][2][2];
			Cube[UP][2][1] = preCube[LEFT][1][2];
			Cube[UP][2][2] = preCube[LEFT][0][2];

			Cube[RIGHT][0][0] = preCube[UP][2][0];
			Cube[RIGHT][1][0] = preCube[UP][2][1];
			Cube[RIGHT][2][0] = preCube[UP][2][2];

			Cube[DOWN][0][0] = preCube[RIGHT][2][0];
			Cube[DOWN][0][1] = preCube[RIGHT][1][0];
			Cube[DOWN][0][2] = preCube[RIGHT][0][0];

			Cube[LEFT][0][2] = preCube[DOWN][0][0];
			Cube[LEFT][1][2] = preCube[DOWN][0][1];
			Cube[LEFT][2][2] = preCube[DOWN][0][2];
		}
		else
		{
			Cube[UP][2][0] = preCube[RIGHT][0][0];
			Cube[UP][2][1] = preCube[RIGHT][1][0];
			Cube[UP][2][2] = preCube[RIGHT][2][0];

			Cube[RIGHT][0][0] = preCube[DOWN][0][2];
			Cube[RIGHT][1][0] = preCube[DOWN][0][1];
			Cube[RIGHT][2][0] = preCube[DOWN][0][0];

			Cube[DOWN][0][0] = preCube[LEFT][0][2];
			Cube[DOWN][0][1] = preCube[LEFT][1][2];
			Cube[DOWN][0][2] = preCube[LEFT][2][2];

			Cube[LEFT][0][2] = preCube[UP][2][2];
			Cube[LEFT][1][2] = preCube[UP][2][1];
			Cube[LEFT][2][2] = preCube[UP][2][0];
		}
		break;
	case BACK:
		if (ccw)
		{
			Cube[UP][0][2] = preCube[RIGHT][2][2];
			Cube[UP][0][1] = preCube[RIGHT][1][2];
			Cube[UP][0][0] = preCube[RIGHT][0][2];

			Cube[LEFT][0][0] = preCube[UP][0][2];
			Cube[LEFT][1][0] = preCube[UP][0][1];
			Cube[LEFT][2][0] = preCube[UP][0][0];

			Cube[DOWN][2][2] = preCube[LEFT][2][0];
			Cube[DOWN][2][1] = preCube[LEFT][1][0];
			Cube[DOWN][2][0] = preCube[LEFT][0][0];

			Cube[RIGHT][0][2] = preCube[DOWN][2][2];
			Cube[RIGHT][1][2] = preCube[DOWN][2][1];
			Cube[RIGHT][2][2] = preCube[DOWN][2][0];
		}
		else
		{
			Cube[UP][0][2] = preCube[LEFT][0][0];
			Cube[UP][0][1] = preCube[LEFT][1][0];
			Cube[UP][0][0] = preCube[LEFT][2][0];

			Cube[LEFT][0][0] = preCube[DOWN][2][0];
			Cube[LEFT][1][0] = preCube[DOWN][2][1];
			Cube[LEFT][2][0] = preCube[DOWN][2][2];

			Cube[DOWN][2][2] = preCube[RIGHT][0][2];
			Cube[DOWN][2][1] = preCube[RIGHT][1][2];
			Cube[DOWN][2][0] = preCube[RIGHT][2][2];

			Cube[RIGHT][0][2] = preCube[UP][0][0];
			Cube[RIGHT][1][2] = preCube[UP][0][1];
			Cube[RIGHT][2][2] = preCube[UP][0][2];
		}
		break;
	case UP:
		if (ccw)
		{
			Cube[BACK][0][2] = preCube[LEFT][0][2];
			Cube[BACK][0][1] = preCube[LEFT][0][1];
			Cube[BACK][0][0] = preCube[LEFT][0][0];

			Cube[RIGHT][0][2] = preCube[BACK][0][2];
			Cube[RIGHT][0][1] = preCube[BACK][0][1];
			Cube[RIGHT][0][0] = preCube[BACK][0][0];

			Cube[FRONT][0][0] = preCube[RIGHT][0][0];
			Cube[FRONT][0][1] = preCube[RIGHT][0][1];
			Cube[FRONT][0][2] = preCube[RIGHT][0][2];

			Cube[LEFT][0][0] = preCube[FRONT][0][0];
			Cube[LEFT][0][1] = preCube[FRONT][0][1];
			Cube[LEFT][0][2] = preCube[FRONT][0][2];
		}
		else
		{
			Cube[BACK][0][2] = preCube[RIGHT][0][2];
			Cube[BACK][0][1] = preCube[RIGHT][0][1];
			Cube[BACK][0][0] = preCube[RIGHT][0][0];

			Cube[RIGHT][0][2] = preCube[FRONT][0][2];
			Cube[RIGHT][0][1] = preCube[FRONT][0][1];
			Cube[RIGHT][0][0] = preCube[FRONT][0][0];

			Cube[FRONT][0][0] = preCube[LEFT][0][0];
			Cube[FRONT][0][1] = preCube[LEFT][0][1];
			Cube[FRONT][0][2] = preCube[LEFT][0][2];

			Cube[LEFT][0][0] = preCube[BACK][0][0];
			Cube[LEFT][0][1] = preCube[BACK][0][1];
			Cube[LEFT][0][2] = preCube[BACK][0][2];
		}
		break;
	case DOWN:
		if (ccw)
		{
			Cube[FRONT][2][0] = preCube[LEFT][2][0];
			Cube[FRONT][2][1] = preCube[LEFT][2][1];
			Cube[FRONT][2][2] = preCube[LEFT][2][2];

			Cube[RIGHT][2][0] = preCube[FRONT][2][0];
			Cube[RIGHT][2][1] = preCube[FRONT][2][1];
			Cube[RIGHT][2][2] = preCube[FRONT][2][2];

			Cube[BACK][2][2] = preCube[RIGHT][2][2];
			Cube[BACK][2][1] = preCube[RIGHT][2][1];
			Cube[BACK][2][0] = preCube[RIGHT][2][0];

			Cube[LEFT][2][2] = preCube[BACK][2][2];
			Cube[LEFT][2][1] = preCube[BACK][2][1];
			Cube[LEFT][2][0] = preCube[BACK][2][0];
		}
		else
		{
			Cube[FRONT][2][0] = preCube[RIGHT][2][0];
			Cube[FRONT][2][1] = preCube[RIGHT][2][1];
			Cube[FRONT][2][2] = preCube[RIGHT][2][2];

			Cube[RIGHT][2][0] = preCube[BACK][2][0];
			Cube[RIGHT][2][1] = preCube[BACK][2][1];
			Cube[RIGHT][2][2] = preCube[BACK][2][2];

			Cube[BACK][2][2] = preCube[LEFT][2][2];
			Cube[BACK][2][1] = preCube[LEFT][2][1];
			Cube[BACK][2][0] = preCube[LEFT][2][0];

			Cube[LEFT][2][2] = preCube[FRONT][2][2];
			Cube[LEFT][2][1] = preCube[FRONT][2][1];
			Cube[LEFT][2][0] = preCube[FRONT][2][0];
		}
		break;
	case LEFT:
		if (ccw)
		{
			Cube[UP][0][0] = preCube[BACK][2][2];
			Cube[UP][1][0] = preCube[BACK][1][2];
			Cube[UP][2][0] = preCube[BACK][0][2];

			Cube[FRONT][0][0] = preCube[UP][0][0];
			Cube[FRONT][1][0] = preCube[UP][1][0];
			Cube[FRONT][2][0] = preCube[UP][2][0];

			Cube[DOWN][2][0] = preCube[FRONT][2][0];
			Cube[DOWN][1][0] = preCube[FRONT][1][0];
			Cube[DOWN][0][0] = preCube[FRONT][0][0];

			Cube[BACK][0][2] = preCube[DOWN][2][0];
			Cube[BACK][1][2] = preCube[DOWN][1][0];
			Cube[BACK][2][2] = preCube[DOWN][0][0];
		}
		else
		{
			Cube[UP][0][0] = preCube[FRONT][0][0];
			Cube[UP][1][0] = preCube[FRONT][1][0];
			Cube[UP][2][0] = preCube[FRONT][2][0];

			Cube[FRONT][0][0] = preCube[DOWN][0][0];
			Cube[FRONT][1][0] = preCube[DOWN][1][0];
			Cube[FRONT][2][0] = preCube[DOWN][2][0];

			Cube[DOWN][2][0] = preCube[BACK][0][2];
			Cube[DOWN][1][0] = preCube[BACK][1][2];
			Cube[DOWN][0][0] = preCube[BACK][2][2];

			Cube[BACK][0][2] = preCube[UP][2][0];
			Cube[BACK][1][2] = preCube[UP][1][0];
			Cube[BACK][2][2] = preCube[UP][0][0];
		}
		break;
	case RIGHT:
		if (ccw)
		{
			Cube[UP][2][2] = preCube[FRONT][2][2];
			Cube[UP][1][2] = preCube[FRONT][1][2];
			Cube[UP][0][2] = preCube[FRONT][0][2];

			Cube[BACK][0][0] = preCube[UP][2][2];
			Cube[BACK][1][0] = preCube[UP][1][2];
			Cube[BACK][2][0] = preCube[UP][0][2];

			Cube[DOWN][0][2] = preCube[BACK][2][0];
			Cube[DOWN][1][2] = preCube[BACK][1][0];
			Cube[DOWN][2][2] = preCube[BACK][0][0];

			Cube[FRONT][0][2] = preCube[DOWN][0][2];
			Cube[FRONT][1][2] = preCube[DOWN][1][2];
			Cube[FRONT][2][2] = preCube[DOWN][2][2];
		}
		else
		{
			Cube[UP][2][2] = preCube[BACK][0][0];
			Cube[UP][1][2] = preCube[BACK][1][0];
			Cube[UP][0][2] = preCube[BACK][2][0];

			Cube[BACK][0][0] = preCube[DOWN][2][2];
			Cube[BACK][1][0] = preCube[DOWN][1][2];
			Cube[BACK][2][0] = preCube[DOWN][0][2];

			Cube[DOWN][0][2] = preCube[FRONT][0][2];
			Cube[DOWN][1][2] = preCube[FRONT][1][2];
			Cube[DOWN][2][2] = preCube[FRONT][2][2];

			Cube[FRONT][0][2] = preCube[UP][0][2];
			Cube[FRONT][1][2] = preCube[UP][1][2];
			Cube[FRONT][2][2] = preCube[UP][2][2];
		}
		break;
	}
}

'Computer Science' 카테고리의 다른 글

Problem B : const구간의 합 구하기(2D)  (0) 2020.01.07
Problem A : 수열  (0) 2020.01.07
루빅의 사각형  (0) 2020.01.07
CPP OOP 유력문제  (0) 2019.07.18
컴퓨터실  (0) 2019.06.11

댓글