[BOJ] 2096 : 내려가기(Java)

문제

N줄에 0 이상 9 이하의 숫자가 세 개씩 적혀 있다. 내려가기 게임을 하고 있는데, 이 게임은 첫 줄에서 시작해서 마지막 줄에서 끝나게 되는 놀이이다.

먼저 처음에 적혀 있는 세 개의 숫자 중에서 하나를 골라서 시작하게 된다. 그리고 다음 줄로 내려가는데, 다음 줄로 내려갈 때에는 다음과 같은 제약 조건이 있다. 바로 아래의 수로 넘어가거나, 아니면 바로 아래의 수와 붙어 있는 수로만 이동할 수 있다는 것이다. 이 제약 조건을 그림으로 나타내어 보면 다음과 같다.

별표는 현재 위치이고, 그 아랫 줄의 파란 동그라미는 원룡이가 다음 줄로 내려갈 수 있는 위치이며, 빨간 가위표는 원룡이가 내려갈 수 없는 위치가 된다. 숫자표가 주어져 있을 때, 얻을 수 있는 최대 점수, 최소 점수를 구하는 프로그램을 작성하시오. 점수는 원룡이가 위치한 곳의 수의 합이다.

 

입력

첫째 줄에 N(1 ≤ N ≤ 100,000)이 주어진다. 다음 N개의 줄에는 숫자가 세 개씩 주어진다. 숫자는 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 중의 하나가 된다.

 

출력

첫째 줄에 얻을 수 있는 최대 점수와 최소 점수를 띄어서 출력한다.

---

💡 풀이

다이나믹 프로그래밍을 이용할 겁니다! dp라는 graph와 같은 크기의 배열을 만들고 이곳에 최대값 혹은 최소값을 계속 저장해간다. dp의 초기값은 -1로 초기화해준다. 보통 DP에서 캐시의 배열에는 할당될 수 없는 값을 입력하는데 보통 -1을 넣는다.

dp배열의 첫 째 줄은 시작부분이기 때문에 graph의 첫 째 줄을 그대로 넣어준다. 그리고 dp에 저장해간다. 

우선, 양쪽에 접근이 가능한지를 검사하고 가능하다면(범위 안이라면), 아래의 값과 더한 뒤 최대, 최소에 맞게 계산해준다. 

메서드를 한 개로 만들기 위해 flag라는 파라미터를 두어 1일 경우 최대값을 구하는 메서드, 0일 경우 최소값을 구하는 메서드로 동작하도록 작성했다. 

주의할 점은 dp를 처음에 -1로 초기화하기 때문에 최소값을 구하는 경우에 그대로 사용하면 -1로 계속 적용이 된다. 이를 처리하기 위해 값이 -1인 경우에는 graph의 값을 그대로 더해주어 최초의 값을 업데이트 해주어야 한다. 

 

전체적인 코드는 다음과 같다.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Q2096 {
    public static int[][] graph;
    public static int[][] dp;
    public static final int MAX=1, MIN=0;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        int N = Integer.parseInt(br.readLine()); // 줄의 수
        graph = new int[N][3];
        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine(), " ");
            for (int j = 0; j < 3; j++) {
                graph[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        dp = new int[N][3];
        for (int[] ints : dp) {
            Arrays.fill(ints, -1);
        }

        // Max 값 계산
        findMaxMin(N, MAX);
        Arrays.sort(dp[N-1]); // dp 배열의 맨 마지막 줄을 정렬했을 때, 제일 끝 값이 최댓값
        System.out.print(dp[N-1][2]+" "); // Max값 출력

        // 다시 dp 배열 초기화
        for (int[] ints : dp) {
            Arrays.fill(ints, -1);
        }

        // Min 값 계산
        findMaxMin(N, MIN);
        Arrays.sort(dp[N-1]);
        System.out.println(dp[N-1][0]);
    }

    public static void findMaxMin(int n, int flag){
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < 3; j++) {
                if(i==0){ // 첫 번째 줄은 시작줄이기 때문에 graph의 값을 그대로 적용
                    dp[i][j] = graph[i][j];
                }
                else {
                    if(flag==1){ // Max값을 구하는 경우
                        dp[i][j] = Math.max(dp[i-1][j] + graph[i][j], dp[i][j]);
                    }
                    else{ // Min값을 구하는 경우
                        if(dp[i][j]==-1){ // 아직 값이 입력되지 않은 경우
                            dp[i][j] = dp[i-1][j] + graph[i][j];
                        }
                        else
                            dp[i][j] = Math.min(dp[i-1][j] + graph[i][j], dp[i][j]);
                    }

                    // 왼쪽으로 가는 경우
                    if(j-1>=0){
                        if(flag==1) // Max값을 구하는 경우
                            dp[i][j] = Math.max(dp[i-1][j-1] + graph[i][j], dp[i][j]);
                        else{
                            if(dp[i][j]==-1){ // 아직 값이 입력되지 않은 경우
                                dp[i][j] = dp[i-1][j-1] + graph[i][j];
                            }
                            else
                                dp[i][j] = Math.min(dp[i-1][j-1] + graph[i][j], dp[i][j]);
                        }
                    }

                    // 오른쪽으로 가는 경우
                    if(j+1<3){
                        if(flag==1)
                            dp[i][j] = Math.max(dp[i-1][j+1] + graph[i][j], dp[i][j]);
                        else{
                            if(dp[i][j]==-1){ // 아직 값이 입력되지 않은 경우
                                dp[i][j] = dp[i-1][j+1] + graph[i][j];
                            }
                            else
                                dp[i][j] = Math.min(dp[i-1][j+1] + graph[i][j], dp[i][j]);
                        }
                    }
                }
            }
        }
    }
}