[백준] code.plus(시뮬레이션과 구현,JAVA)16939번, 2×2×2 큐브

문제 링크

16939번: 2×2×2 큐브

---

주의사항

• JAVA를 사용하여 프로그램을 사용하였습니다.
• 백준에서 코드를 작성하였을 때 아래 형태에서 Main에서 결과가 출력되어야 합니다.

public class Main{ 	
	public static void main(String[] args){
    }
}

---

문제 설명

---

접근 방법

 

이 문제에 핵심은

 

1. 2×2×2 큐브에서 각 면을 양방향으로 90도 돌릴 때 큐브를 풀 수 있으면 1 아니면 0을 결과로 출력한다. 

2. 큐브에 값들은 문제에서 설명한 Index의 값을 가지고 있다.

3. 큐브에 색은 1~6으로 표현합니다.

 

알고리즘 진행 순서.

 

1. 입력되는 정보들을 저장합니다.

 

2. 각 면을 양방향으로 90도 돌려보면서 큐브가 풀리는지 시뮬레이션을 진행합니다.

 

3. 시뮬레이션 중에 큐브가 풀리면 1, 풀리지 않으면 0을 결과로 출력합니다.

 

설명하기 앞서 저는 이 문제를 풀면서 공간 지각 능력이 정말 떨어진다고 생각이 들어서 자괴감이 살짝 왔으며 문제를 푸는데에도 꽤 많은 시간(3시간?)을 소요하였습니다.

 

저는 시뮬레이션을 진행할 때 각 면이 돌아가는 것을 (5, 6, 7, 8)면을 기준으로 돌리면서 큐브의 값들이 바뀌는 것을 구현하였습니다.

(17, 18, 19, 20)면 회전

(13, 14, 15, 16)면 회전

(1, 2, 3, 4)면 회전

(9, 10, 11, 12)면 회전

(5, 6, 7, 8)면 회전

(21, 22, 23, 24)면 회전

예제입력 2.

 

1. 입력되는 정보들을 저장합니다.

 

1 ~ 24개의 색을 저장합니다.

 

2. 각 면을 양방향으로 90도 돌려보면서 큐브가 풀리는지 시뮬레이션을 진행합니다.

 

(17, 18, 19, 20)면을 회전할 때 큐브가 풀어집니다.

 

3. 시뮬레이션 중에 큐브가 풀리면 1, 풀리지 않으면 0을 결과로 출력합니다.

 

시뮬레이션 중에 풀렸기 때문에 1을 결과로 출력합니다.

 

• BufferedReader를 사용하여 입력 값을 받았습니다.
• StringTokenizer를 이용하여 입력된 정보에 대하여 나누었습니다.
• cubeMove을 실행하여 시뮬레이션을 진행합니다.
• 시뮬레이션 종료 후 큐브가 풀어졌으면 1, 아니면 0을 BufferedWriter 저장하였습니다.
• BufferedWriter에 저장된 결과값을 출력하였습니다.

• cubeMove함수는 leftToUp, leftToDown, rightToUp.... 을 이용하여 시뮬레이션을 진행합니다.
• leftToUp, leftToDown, rightToUp....함수는 각 큐브의 면을 돌려서 값을 변경을 진행합니다.
• cubeCheck함수는 큐브에 면을 돌린 후 풀렸는지 확인합니다.

 

import java.io.*;
import java.util.StringTokenizer;

public class Main {
    static int[] cube = new int[25];	//큐브에 대한 정보 저장 배열
    public static void main(String[] args) throws IOException {
        //입력값 처리하는 BufferedReader
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //결과값 출력하는 BufferedWriter
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        StringTokenizer st = new StringTokenizer(br.readLine()," ");
        //큐브 정보 저장
        for(int i=1;i<25;i++)
            cube[i] = Integer.parseInt(st.nextToken());
        bw.write(cubeMove() + "");		//큐브 시뮬레이션 시작 및 결과 BufferedWriter 저장
        bw.flush();		//결과 출력
        bw.close();
        br.close();
    }
    //큐브 모든 면 90도로 양방향 회전해보는 시뮬레이션 진행
    static int cubeMove(){
        //(13, 14, 15, 16)면 회전
        leftToUp();		
        if(cubeCheck())
            return 1;
        leftToDown();

        leftToDown();
        if(cubeCheck())
            return 1;
        leftToUp();
        
        //(17, 18, 19, 20)면 회전
        rightToUp();
        if(cubeCheck())
            return 1;
        rightToDown();
        
        rightToDown();
        if(cubeCheck())
            return 1;
        rightToUp();

        //(1, 2, 3, 4)면 회전
        upToRight();
        if(cubeCheck())
            return 1;
        upToLeft();

        upToLeft();
        if(cubeCheck())
            return 1;
        upToRight();

        //(9, 10, 11, 12)면 회전
        downToRight();
        if(cubeCheck())
            return 1;
        downToLeft();

        downToLeft();
        if(cubeCheck())
            return 1;
        downToRight();

        //(5, 6, 7, 8)면 회전
        bottomToLeft();
        if(cubeCheck())
            return 1;
        bottomToRight();

        bottomToRight();
        if(cubeCheck())
            return 1;
        bottomToLeft();

        //(21, 22, 23, 24)면 회전
        topToLeft();
        if(cubeCheck())
            return 1;
        topToRight();

        topToRight();
        if(cubeCheck())
            return 1;
        topToLeft();

        return 0;
    }
    //(13, 14, 15, 16)면 반시계 회전
    static void leftToUp(){
        int t1 = cube[1];
        int t2 = cube[3];
        cube[3] = cube[22];
        cube[1] = cube[24];
        cube[24] = cube[9];
        cube[22] = cube[11];
        cube[9] = cube[5];
        cube[11] = cube[7];
        cube[5] = t1;
        cube[7] = t2;
    }
    //(13, 14, 15, 16)면 시계 회전
    static void leftToDown(){
        int t1 = cube[1];
        int t2 = cube[3];
        cube[1] = cube[5];
        cube[3] = cube[7];
        cube[5] = cube[9];
        cube[7] = cube[11];
        cube[9] = cube[24];
        cube[11] = cube[22];
        cube[22] = t2;
        cube[24] = t1;
    }
    //(17, 18, 19, 20)면  시계 회전
    static void rightToUp(){
        int t1 = cube[2];
        int t2 = cube[4];
        cube[4] = cube[21];
        cube[2] = cube[23];
        cube[23] = cube[10];
        cube[21] = cube[12];
        cube[10] = cube[6];
        cube[12] = cube[8];
        cube[6] = t1;
        cube[8] = t2;
    }
    //(17, 18, 19, 20)면 반시계 회전
    static void rightToDown(){
        int t1 = cube[2];
        int t2 = cube[4];
        cube[2] = cube[6];
        cube[4] = cube[8];
        cube[6] = cube[10];
        cube[8] = cube[12];
        cube[10] = cube[23];
        cube[12] = cube[21];
        cube[21] = t2;
        cube[23] = t1;
    }
    //(1, 2, 3, 4)면 반시계 회전
    static void upToRight(){
        int t1 = cube[13];
        int t2 = cube[14];
        cube[13] = cube[22];
        cube[14] = cube[21];
        cube[21] = cube[18];
        cube[22] = cube[17];
        cube[17] = cube[5];
        cube[18] = cube[6];
        cube[5] = t1;
        cube[6] = t2;
    }
    //(1, 2, 3, 4)면 시계 회전
    static void upToLeft(){
        int t1 = cube[13];
        int t2 = cube[14];
        cube[13] = cube[5];
        cube[14] = cube[6];
        cube[5] = cube[17];
        cube[6] = cube[18];
        cube[17] = cube[22];
        cube[18] = cube[21];
        cube[21] = t2;
        cube[22] = t1;
    }
    //(9, 10, 11, 12)면 시계 회전
    static void downToRight(){
        int t1 = cube[15];
        int t2 = cube[16];
        cube[15] = cube[24];
        cube[16] = cube[23];
        cube[23] = cube[20];
        cube[24] = cube[19];
        cube[19] = cube[7];
        cube[20] = cube[8];
        cube[7] = t1;
        cube[8] = t2;
    }
    //(9, 10, 11, 12)면 반시계 회전
    static void downToLeft(){
        int t1 = cube[15];
        int t2 = cube[16];
        cube[15] = cube[7];
        cube[16] = cube[8];
        cube[7] = cube[19];
        cube[8] = cube[20];
        cube[19] = cube[24];
        cube[20] = cube[23];
        cube[23] = t2;
        cube[24] = t1;
    }
    //(5, 6, 7, 8)면 반시계 회전
    static void bottomToLeft(){
        int t1 = cube[5];
        int t2 = cube[4];
        cube[5] = cube[6];
        cube[6] = cube[8];
        cube[8] = cube[7];
        cube[7] = t1;
        t1 = cube[3];
        cube[3] = cube[17];
        cube[4] = cube[19];
        cube[17] = cube[10];
        cube[19] = cube[9];
        cube[9] = cube[14];
        cube[10] = cube[16];
        cube[14] = t2;
        cube[16] = t1;
    }
    //(5, 6, 7, 8)면 시계 회전
    static void bottomToRight(){
        int t1 = cube[5];
        int t2 = cube[4];
        cube[5] = cube[7];
        cube[7] = cube[8];
        cube[8] = cube[6];
        cube[6] = t1;
        t1 = cube[3];
        cube[3] = cube[16];
        cube[4] = cube[14];
        cube[14] = cube[9];
        cube[16] = cube[10];
        cube[9] = cube[19];
        cube[10] = cube[17];
        cube[17] = t1;
        cube[19] = t2;
    }
    //(21, 22, 23, 24)면 반시계 회전
    static void topToLeft(){
        int t1 = cube[21];
        int t2 = cube[2];
        cube[21] = cube[22];
        cube[22] = cube[24];
        cube[24] = cube[23];
        cube[23] = t1;
        t1 = cube[1];
        cube[1] = cube[18];
        cube[2] = cube[20];
        cube[18] = cube[12];
        cube[20] = cube[11];
        cube[11] = cube[13];
        cube[12] = cube[15];
        cube[13] = t2;
        cube[15] = t1;
    }
    //(21, 22, 23, 24)면 시계 회전
    static void topToRight(){
        int t1 = cube[21];
        int t2 = cube[2];
        cube[21] = cube[23];
        cube[23] = cube[24];
        cube[24] = cube[22];
        cube[22] = t1;
        t1 = cube[1];
        cube[1] = cube[15];
        cube[2] = cube[13];
        cube[13] = cube[11];
        cube[15] = cube[12];
        cube[11] = cube[20];
        cube[12] = cube[18];
        cube[18] = t1;
        cube[20] = t2;
    }

    //큐브 풀었는지 확인하는 함수
    static boolean cubeCheck(){
        for(int i=1;i<25;i+=4){
            if(cube[i] != cube[i+1] || cube[i+1]!=cube[i+2] || cube[i+2] != cube[i+3])
                return false;
        }
        return true;
    }
}