[백준, 자바] 17404번 - RGB2

문제 링크
https://www.acmicpc.net/problem/17404

최종 코드(정답)

import java.io.IOException;
import java.util.List;
import java.util.Scanner;

public class Main_17404 {

    public static void main(String[] args) throws IOException {
       Scanner sc = new Scanner(System.in);
       int n = sc.nextInt();
       int[][]list = new int[n+1][n+1]; // 페인트 칠 전체 비용 리스트
       int[][]dp = new int[n+1][n+1]; // 칠한 집 idx를 담은 dp[2][1]은 집 2개의 마지막집을 초록색으로 칠했을 때 드는 최소 비용
       int[]paint = new int[n+1]; // 최소비용

        // 일단 배열 초기화
        for(int i=1;i<=n;i++) {
            for (int j = 0; j < 3; j++) {
                list[i][j] = sc.nextInt();
            }
        }

       // 첫번째 집 칠하기
       for(int i = 0; i < 3; i++) {
           for(int j = 0; j < 3; j++) {
               if (i==j) {
                   dp[1][j] = list[1][j];
               } else {
                     dp[1][j] = 1001;
               }
               /**
                *  dp = [
                *   [0, 0, 0],
                *   [26, 1001, 1001],
                *   [1001, 40, 1001], // 여기서부터 for문 k=2의 시작
                *   [1001, 1001, 83]
                * ]
                */
           }

           for (int k = 2; k < n + 1; k++) {
               int prevHouse = k - 1;

               dp[k][0] = list[k][0] + Math.min(dp[prevHouse][prevHouseList(0).get(0)], dp[prevHouse][prevHouseList(0).get(1)]); // red면 이전 집은 green, blue
               dp[k][1] = list[k][1] + Math.min(dp[prevHouse][prevHouseList(1).get(0)], dp[prevHouse][prevHouseList(1).get(1)]); // green
               dp[k][2] = list[k][2] + Math.min(dp[prevHouse][prevHouseList(2).get(0)], dp[prevHouse][prevHouseList(2).get(1)]); // blue

               System.out.println("dp[k][0] = " + dp[k][0]);
               System.out.println("dp[k][0] = " + dp[k][1]);
               System.out.println("dp[k][0] = " + dp[k][2]);

               if (k==n) {
                   // n+1을 길이로 설정했으므로, 마지막 idx는 n이 될 것이다.
                   paint[i] = Math.min(dp[n][prevHouseList(i).get(0)], dp[n][prevHouseList(i).get(1)]);
               }
           }
       }

        System.out.println(Math.min(paint[0], Math.min(paint[1], paint[2])));
    }
   static List<Integer> prevHouseList (int house) {
        // 0: red, 1: green, 2: blue
       if (house == 1) {
           return List.of(0, 2);
       } else if (house == 2) {
           return List.of(0, 1);
       } else {
           return List.of(1, 2);
       }
   }
}

풀이

가능한 이전 집의 index를 prevHouseList 함수로 만들었다.
원래 idx로 하나하나 하는데 나의 경우 이해를? 전혀 못하기 때문에 함수로 뽑아서 거기서 범위 설정하고 거기만 체크했다.

dp[k][색깔 index] = Math.min(이전집1의 비용, 이전집2의 비용)

n번째에서 (n+1 길이이므로 마지막이 n) 각각 색깔로 집을 칠했을 때 비용 경우의 수가 3개 나온다. 거기서 최솟값이 답이다.

후기
정답률이 높은데 난 좀 어려웠다.
아직도 dp를 어떻게 설정할 지 감이 안 잡힌다.