9-H0ngJu

[H0ngJu]

🔗 문제 링크

RGB거리 2

✔️ 소요된 시간

2시간 30분

✨ 수도 코드

RGB 거리를 먼저 풀고 RGB 거리 2를 풀었습니다.

일단 RGB 거리의 구현은 간단합니다.

i번째 집과 i+1번째의 색이 같지 않으면서 최소 비용을 선택하기만 하면 됩니다.

먼저 dp는 3*N배열로 선언합니다. 각 열에는 R(0), G(1), B(2)에 대한 최소 비용을 저장합니다.

1번 집만 2차원 dp[[i]에 먼저 저장해두고,
i 번째 집은 i-1번째에서 색칠하지 않은 두 색 중 최소를 선택하는 것이므로,

dp[i][0] = min(dp[i-1][1], dp[i-1][2]) + house[i][0]
# i번째에 R(0)을 색칠하는 경우

로 구현하면 됩니다.

import sys

def input(): return sys.stdin.readline().rstrip()

N = int(input())

house = [[int(x) for x in input().split()] for _ in range(N)]

dp = [[0] * 3 for _ in range(N)]

for i in range(N):
    if i == 0:
        dp[i] = house[i]
    else:
        dp[i][0] = min(dp[i-1][1], dp[i-1][2]) + house[i][0]
        dp[i][1] = min(dp[i-1][0], dp[i-1][2]) + house[i][1] 
        dp[i][2] = min(dp[i-1][0], dp[i-1][1]) + house[i][2] 

print(min(dp[N-1]))

RGB 거리 2에서는 RGB 거리문제와 똑같지만 '1번 집과 N번 집의 색이 다를 것'이라는 조건이 추가가 됩니다.
처음에 해당 조건을 보고 처음엔 바로 원형 연결리스트를 떠올렸으나, RGB 거리 코드에서 조금만 수정하면 될 것 같아서 원형 연결리스트로는 구현하지 않았습니다.

1번 집의 색을 저장해둘 수만 있다면 N번 집의 컬러는 해당 컬러를 제외하고 최소 비용을 구하면 되므로
쉽게 구현될거라 생각했지만,,

문제는 '1번 집의 색을 어떻게 저장해둘 것인가?'에서 발생하였습니다.

f_hose 라는 배열을 만들어서 색을 저장해두면, dp 선택과정에서 기존 RGB 거리 코드에서 min( dp[i-1][ ], dp[i-1][ ])를 선택하는 과정에서 계속해서 f_hose의 위치가 계속해서 바뀌기 때문에 처리가 불가능하다고 생각하였습니다.

그래서 결국 단순하게
1번집 색에 따른 코드를 각각 구현하고 dp도 dp0,dp1,dp2로 다 따로 구현하여 min을 선택하는 코드를 작성하였습니다.

코드보기

import sys

def input(): return sys.stdin.readline().rstrip()

N = int(input())

house = [[int(x) for x in input().split()] for _ in range(N)]

dp0 = [[0] * 3 for _ in range(N)]
dp1 = [[0] * 3 for _ in range(N)]
dp2 = [[0] * 3 for _ in range(N)]

INF = 1000*1000+1

# 1번에 (0)을 색칠하는 경우
for i in range(N):
    if i == 0:
        dp0[i][0] = house[i][0]
        dp0[i][1] = INF
        dp0[i][2] = INF
        #print(i, ":", dp0[i])
    elif i == N-1:
        dp0[i][0] = INF # 0은 색칠 불가이므로
        dp0[i][1] = dp0[i-1][2] + house[i][1] 
        dp0[i][2] = dp0[i-1][1] + house[i][2]
        #print(i,":", dp0[i])
    else: 
        dp0[i][0] = min(dp0[i-1][1], dp0[i-1][2]) + house[i][0]
        dp0[i][1] = min(dp0[i-1][0], dp0[i-1][2]) + house[i][1] 
        dp0[i][2] = min(dp0[i-1][0], dp0[i-1][1]) + house[i][2]
        #print(i,":", dp0[i])

# 1번에 (1)을 색칠하는 경우
for i in range(N):
    if i == 0:
        dp1[i][0] = INF
        dp1[i][1] = house[i][1]
        dp1[i][2] = INF
    elif i == N-1:
        dp1[i][0] = dp1[i-1][2] + house[i][0]
        dp1[i][1] = INF
        dp1[i][2] = dp1[i-1][0] + house[i][2]
    else: 
        dp1[i][0] = min(dp1[i-1][1], dp1[i-1][2]) + house[i][0]
        dp1[i][1] = min(dp1[i-1][0], dp1[i-1][2]) + house[i][1] 
        dp1[i][2] = min(dp1[i-1][0], dp1[i-1][1]) + house[i][2]

# 1번에 (2)을 색칠하는 경우
for i in range(N):
    if i == 0:
        dp2[i][0] = INF
        dp2[i][1] = INF
        dp2[i][2] = house[i][2]
    elif i == N-1:
        dp2[i][0] = dp2[i-1][1] + house[i][0]
        dp2[i][1] = dp2[i-1][2] + house[i][1] 
        dp2[i][2] = INF 
    else: 
        dp2[i][0] = min(dp2[i-1][1], dp2[i-1][2]) + house[i][0]
        dp2[i][1] = min(dp2[i-1][0], dp2[i-1][2]) + house[i][1] 
        dp2[i][2] = min(dp2[i-1][0], dp2[i-1][1]) + house[i][2]
        

print(min(min(dp0[N-1]), min(dp1[N-1]), min(dp2[N-1])))

근데 계속 틀렸습니다가 나왔습니다 ... 질문게시판에 있는 반례도 통과하던데 왜 틀린건지 모르겠더라고요.. 😭😭

그래서 다른 레퍼런스의 아이디어만 살짝 참고해서 RGB 거리 기본 코드에서 조금만 수정하였습니다.

아이디어의 핵심은 '1번 집의 color를 저장해두는 것이 아니라, 1번 집의 color가 dp[N-1]에서 선택되지 못하도록 하는 것'입니다.

1. 1번집의 컬러를 선택할 반복문 시행 (0~2까지)
2. dp는 INF로 초기화
   1. 기본 RGB dp 로직 수행
3. dp[N-1][first_hose_color]는 INF로 변경 -> min에서 선택되지 않도록
4. cost에는 각 1번집 컬러에 대하여 최솟값을 선택하여 저장

📚 새롭게 알게된 내용

[tgyuuAn]

홍주님 코드가 깔끔해진게 눈에 보여서 좋네요!

이 문제 보자마자 파이썬에 도둑질 을 떠올렸습니다.

이 문제랑 상당히 유사하고 프로그래머스 레벨 3문제니 홍주님 꼭 풀어보세요!

대충 풀이를 알고있음에도 시간이 조금 걸렸습니다.

분명 맞는 코든데 왜 2%에서 틀렸지를 하고 반례를 찾아보니

5
1 10 100
1 10 100
1 10 100
1 10 100
1 10 100

의 결과로 122가 나와야하는데 자꾸 32를 뱉더라고요 ...

그래도 예전에 비슷한 문제를 풀어봤다고 30분 정도 더 투자하고 풀 수 있었습니다 ^^;;;

쉽지 않은 문제인데 골드 문제를 도전해보시다니 너무 대견해요...!

앞으로도 빠이팅!!!!!!!!!!!!!!

import sys

def input(): return sys.stdin.readline().rstrip()

N = int(input())
costs = [list(map(int,input().split())) for _ in range(N)]
answer = int(1e9)

# 끝부분 색칠하고 시작.
for color in range(3):
    DP = [[int(1e9) for _ in range(3)] for _ in range(N+1)]
    DP[0][color] = 0
    
    for idx in range(1,N+1):
        for idx_color in range(3):
            if idx == 1 and idx_color == color: continue
            if idx == N-1 and idx_color == color: continue
            if idx == N and idx_color != color: continue
            
            for diff_color in range(3):
                if idx_color != diff_color:
                    DP[idx][idx_color] = min(DP[idx][idx_color], costs[idx-1][idx_color] + DP[idx-1][diff_color])
    
    answer = min(answer, DP[-1][0], DP[-1][1], DP[-1][2])
    
print(answer)

[miniron-v]

주문하신 반례입니다.

elif i == N-1:
        dp0[i][0] = INF # 0은 색칠 불가이므로
        dp0[i][1] = dp0[i-1][2] + house[i][1] 
        dp0[i][2] = dp0[i-1][1] + house[i][2]

여기서, i == N-1일 때 dp0[i][1]의 최적해가 dp0[i-1][0] + house[i][1]일 수 있습니다.

첫 칸이 0번 색이니 N-1번 칸이 0이 아니어야 할 뿐, N-2번째 칸은 0번 색이 칠해질 수 있습니다.

[pknujsp]

예전에 RGB거리1 풀었던 기억때문에 2번이 금방 풀릴줄 알았는데 아니네요

n = int(stdin.readline())
houses = [list(map(int, stdin.readline().split())) for _ in range(n)]

for i in range(1, n):
    houses[i][0] += min(houses[i - 1][1], houses[i - 1][2])
    houses[i][1] += min(houses[i - 1][0], houses[i - 1][2])
    houses[i][2] += min(houses[i - 1][0], houses[i - 1][1])

print(min(houses[-1]))

맨 끝 집에 대해서 조건이 조금만 달라졌는데도 좀 까다로워 지네요

• 모든 비용의 합을 저장할 리스트 생성 : 집 개수와 같은 크기를 가지는 costs 리스트를 만들어서 가능한 모든 경우의 최소 합을 구해나갑니다
  • 리스트 각 원소의 크기는 3이고, RGB 각각을 칠해나간 비용 합을 저장
• min_costs에 최소 비용 합을 저장
• 비용 계산 : R, G, B 각각의 색상을 첫번째 집에 색칠하는 걸로 시작하는 경우로 시작해서 모든 집에 칠해봅니다
  • 첫 번째 집에 대해서는 시작 색상에 따라 비용을 설정
  • 나머지 색상에는 매우 큰 값을(INF) 설정
  • 만약 R을 칠한다면 [비용, INF, INF] 과 같이 한다
• 두번째 집부터 마지막 집까지 인접한 집의 색상과 안 겹치도록 칠하는 비용을 계산한다
• 최소 비용 갱신 : min_costs를 costs의 마지막 원소 내 최솟값과 비교해서 갱신
• 세 가지 색상 전부에 대한 경우를 탐색한 후 min_costs를 출력하면 최소 비용이 나옵니다

N = int(input())
INF = int(1e7)

arr = [list(map(int, input().split())) for _ in range(N)]
costs = [[0] * 3 for _ in range(N)]
min_cost = INF

for first_color in range(3): 
    
    for color in range(3):
        costs[0][color] = arr[0][color] if color == first_color else INF
            
    for i in range(1, N):
        costs[i][0] = min(costs[i - 1][1], costs[i - 1][2]) + arr[i][0]
        costs[i][1] = min(costs[i - 1][0], costs[i - 1][2]) + arr[i][1]
        costs[i][2] = min(costs[i - 1][0], costs[i - 1][1]) + arr[i][2]

    for color in range(3):
        if color != first_color:
            min_cost = min(min_cost, costs[-1][color])

print(min_cost)

[H0ngJu]

주문하신 반례입니다.

elif i == N-1:
        dp0[i][0] = INF # 0은 색칠 불가이므로
        dp0[i][1] = dp0[i-1][2] + house[i][1] 
        dp0[i][2] = dp0[i-1][1] + house[i][2]

여기서, i == N-1일 때 dp0[i][1]의 최적해가 dp0[i-1][0] + house[i][1]일 수 있습니다.

첫 칸이 0번 색이니 N-1번 칸이 0이 아니어야 할 뿐, N-2번째 칸은 0번 색이 칠해질 수 있습니다.

민철치,, 감사합니다 (_ _) 그러네요 ... 음... 어 ....... 왜 이걸 생각못했을까 허헛
반례 찾아주어 감사합니둥 😎