🥇[백준] 2116 주사위 쌓기 (골드5) / dict() ; rotate[key] >> value

문제요약

나의 코드 및 설명

• 1번 주사위는 마음대로 놓을 수 있다고 했으므로, 1번 주사위에 따라 나머지 위에 쌓여진 주사위들의 숫자가 결정난다고 생각을 하였다. 따라서 dice(first) 메서드를 통해 1번 주사위의 윗면에 오는 숫자가 입력받은 1번 주사위의 몇 번 인덱스인지에 따라 다른 주사위들의 옆면 숫자가 달라지도록 코드를 작성하였다.
• 그림1을 보아, 윗면 인덱스가 0, 1, 2, 3, 4, 5 라면 아랫면 인덱스는 각각 5, 3, 4, 1, 2, 0 이 되는 것을 알 수 있다.
• 1번 주사위의 옆면 숫자의 최댓값을 dice_sum에 저장해두고, 이 후 for문을 통해 2번 주사위부터 마지막 주사위까지의 옆면 숫자의 최댓값을 순차적으로 더한다.
• dice() 메서드가 종료될 때 미리 초기화해두었던 result 리스트에 값을 저장한다. 
• for문을 통해 1번 주사위의 윗면이 0~5번 인덱스의 값이 될 때를 각각 수행하여, result 리스트에 총 6개의 값이 저장되게 된다.
• result 리스트에 저장된 6개의 값중 최댓값을 출력한다.

n = int(input())
dice_list = []

for i in range(n):
    dice_list.append(list(map(int, input().split())))
    # [[2 3 1 6 5 4],[3 1 2 4 6 5],[5 6 4 1 3 2],[1 3 6 2 4 5],[4 1 6 5 2 3]]

result = []
dice_sum = 0
#첫 번째 주사위를 어떻게 두느냐에 따라 위에 놓이는 주사위들의 최대 눈금이 정해진다.
def dice(first): #첫 번째 주사위의 윗면 인덱스
    global dice_sum 
    dice_sum = 0
    if first == 0: #첫 번째 주사위의 윗면 인덱스가 0 일 때
        up = 0
        #첫 번째 주사위의 윗면 인덱스가 0일 때, 아랫면 인덱스는 5이다. 
        #따라서, 위아랫면을 제외한 나머지 인덱스 1,2,3,4 중 가장 큰 숫자를 저장한다.
        dice_sum = max(dice_list[0][1],dice_list[0][2],dice_list[0][3],dice_list[0][4])
    elif first == 1:
        up = 1
        dice_sum = max(dice_list[0][0],dice_list[0][2],dice_list[0][4],dice_list[0][5])
    elif first == 2:
        up = 2
        dice_sum = max(dice_list[0][0],dice_list[0][1],dice_list[0][3],dice_list[0][5])
    elif first == 3:
        up = 3 
        dice_sum = max(dice_list[0][0],dice_list[0][2],dice_list[0][4],dice_list[0][5])
    elif first == 4:
        up = 4
        dice_sum = max(dice_list[0][0],dice_list[0][1],dice_list[0][3],dice_list[0][5])
    else:
        up = 5
        dice_sum = max(dice_list[0][1],dice_list[0][2],dice_list[0][3],dice_list[0][4])
    #두 번째 주사위 부터의 옆면 숫자들의 합  
    for i in range(0,n-1): 
        for j in range(6):
            #첫 번째 주사위의 윗면과 닿는 두 번째 주사위의 인덱스 j를 찾는다.
            if dice_list[i][up] == dice_list[i+1][j]:
                #j가 0 일때,
                if j == 0:
                    #두 번째 주사위의 윗면은 5가 된다.
                    up = 5
                    #그리고, 위아랫면의 인덱스를 제외한 나머지 숫자 중 가장 큰 수를 dice_sum에 저장한다.
                    dice_sum += max(dice_list[i+1][1],dice_list[i+1][2],\
                                    dice_list[i+1][3],dice_list[i+1][4])
                    break #만약 j를 찾는다면 j를 찾는 반복문을 탈출하고, 
                          #세 번째 주사위와 두 번째 주사위가 만나는 인덱스를 찾는다. (i = 1)
                elif j == 1:
                    up = 3
                    dice_sum += max(dice_list[i+1][0],dice_list[i+1][2],\
                                    dice_list[i+1][4],dice_list[i+1][5])
                    break
                elif j == 2:
                    up = 4
                    dice_sum += max(dice_list[i+1][0],dice_list[i+1][1],\
                                    dice_list[i+1][3],dice_list[i+1][5])
                    break
                elif j == 3:
                    up = 1
                    dice_sum += max(dice_list[i+1][0],dice_list[i+1][2],\
                                    dice_list[i+1][4],dice_list[i+1][5])
                    break
                elif j == 4:
                    up = 2
                    dice_sum += max(dice_list[i+1][0],dice_list[i+1][1],\
                                    dice_list[i+1][3],dice_list[i+1][5])
                    break       
                elif j == 5:
                    up = 0
                    dice_sum += max(dice_list[i+1][1],dice_list[i+1][2],\
                                    dice_list[i+1][3],dice_list[i+1][4])
                    break
    result.append(dice_sum)

#첫 번째 주사위의 윗면이 인덱스 0~5 일때의 옆면 숫자의 합을 result 리스트에 저장한다.
for i in range(6):
    dice(i)

#옆면 숫자의 합 중 가장 큰 값을 출력한다.
print(max(result))

다른 코드 및 설명

• rotate = {0:5, 1:3, 2:4, 3:1, 4:2, 5:0} : 주사위 아랫면에 따른 윗면을 간편하게 추출하기 위해 사용
• temp.remove(dice[0][i]) : 아랫면을 제거한다.
  next = dice[0][rotate[i]] : next 값을 초기화하는데, 1번 주사위의 윗면을 계산한다.
  temp.remove(next) : 윗면을 제거한다.
• 내부 for문에서 2번 주사위부터 마지막 주사위까지의 옆면의 최댓값을 result에 저장한다.
  이후 외부 for문을 돌며 1번 주사위의 아랫면에 올 수 있는 추가적인 5가지 경우의 수를 모두 계산한다.

n = int(input())
dice = []
for _ in range(n):
    dice.append(list(map(int, input().split())))
rotate = {0:5, 1:3, 2:4, 3:1, 4:2, 5:0} #주사위 아랫면에 따른 윗면 로테이션 등록

maxnum = 0 #최댓값을 저장해둘 변수 선언
for i in range(6): #첫 번째 주사위를 기준으로 1~6까지 모두 순회
    result = [] #각 주사위마다 옆면의 최댓값 1개를 저장해둘 리스트 선언
    temp = [1,2,3,4,5,6] # 주사위 각 면에 써져있는 1~6
    temp.remove(dice[0][i]) #주사위 아랫면의 숫자 제거
    next = dice[0][rotate[i]] #첫 번째 주사위의 윗면 값 계산
    temp.remove(next)
    result.append(max(temp)) #첫 번째 주사위의 옆면들 중 가장 큰 값 삽입 
    for j in range(1,n): #두 번째 주사위부터 마지막 주사위 까지 반복
        temp = [1,2,3,4,5,6]
        temp.remove(next) #현재 주사위의 아랫면 숫자 제거
        next = dice[j][rotate[dice[j].index(next)]] #현재 주사위의 윗면 계산
        temp.remove(next) #현재 주사위의 윗면 삭제
        result.append(max(temp))
    result = sum(result)
    if maxnum < result:
        maxnum = result
print(maxnum)

피드백

약 2시간 30분정도 걸려서 풀었다. 사실 어떻게 문제를 풀 것인지는 금방 찾아냈으나 그것을 구현하는 것이 쉽지 않았다. 특히 for문을 여러 번 사용해야하는 경우가 너무 헷갈렸고, 이럴수록 예제를 집중해서 파고들어야 되는데, 자꾸 집중력이 흐트러지는 바람에 더욱 어려웠다. 하지만 첫 골드 문제 도전인 만큼 꼭 내 풀이방식대로 풀어보고 싶었고, 비록 하드코딩이었고 그만큼 노가다도 많이해서 지저분한 코드가 되었지만 어떻게든 내 힘으로 풀어냈기에 너무 뿌듯하였다.

요즘 토이 프로젝트를 준비하느라 바빠서 백준 문제에 소홀했는데(토이 프로젝트, CS지식 공부, 백준 문제풀이, 복습.. 할 게 너무 많다..), 그 대가로 문제풀이가 쉽지 않았다.. 극복하고 싶었고 이번 골드 문제를 solved한 것을 계기로 다시 탄력받아 열심히 준비해야겠다.

 

사전자료형 : dict()

rotate = {0:5, 1:3, 2:4, 3:1, 4:2, 5:0}
print(rotate[0])
>> 5