[이코테] 다양한 동적 계획법(DP) 문제 풀이 - JAVA 자바

개미전사

개미전사는 부족한 식량을 충당하고자 메뚜기 마을의 식량창고를 몰래 공격하려고 한다. 메뚜기 마을에는 여러 개의 식량창고가 있는데 식량창고는 일직선으로 이어져 있다. 각 식량창고에는 정해진 수의 식량을 저장하고 있으며 개미 전사는 식량창고를 선택적으로 약탈하여 식량을 빼앗을 예정이다. 이때 메뚜기 정찰병들은 일직선상에 존재하는 식량창고 중에서 서로 인접한 식량창고가 공격받으면 바로 알아챌 수 있다.

따라서 개미 전사가 정찰병에게 들키지 않고 식량창고를 약탈하기 위해서는 최소한 한 칸 이상 떨어진 식량창고를 약탈해야 한다. 개미 전사는 식량창고가 일직선상일 때 최대한 많은 식량을 얻기를 원한다.개미 전사를 위해 식량창고 N개에 대한 정보가 주어졌을 때 얻을 수 있는 식량의 최댓값을 구하는 프로그램을 작성하시오. ( 3≤N≤100)

[입력]
4 1 3 1 5
[출력]
8

• arr[i] : i번째 식량 창고에 있는 식량의 양
• dp[i] : i번째 식량 창고까지의 최대 식량의 양

문제에서 최소한 한 칸 이상 떨어진 식량창고를 약탈해야 한다. 라는 조건이 있기에 i 번째 식량창고까지 약탈한 식량은 i번째 식량창고를 선택하지 않을 경우와 i번째 식량창고를 선택하는 경우 두 가지 경우만 확인하면 된다.

 

i번째 식량창고를 선택하는 경우에는 인접한 식량창고는 선택할 수 없기에 i-2번째 식량창고 까지의 최대 식량의 양인 dp[i-2] 에 i번째 식량의 양을 더해주면 된다.

dp[i] = max ( arr[i-1], arr[i-2] + arr[i] )

 

👩🏻‍💻 소스코드

public class Main {

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

        int N = Integer.parseInt(br.readLine());
        int[] arr = new int[N];

        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < N; i++) 
            arr[i] = Integer.parseInt(st.nextToken());

        dp[0] = arr[0];
        dp[1] = Math.max(arr[0], arr[1]);
        for (int i = 2; i < N; i++) 
            dp[i] = Math.max(dp[i - 1], dp[i - 2] + arr[i]);

        System.out.println(dp[N - 1]);
    }
}

---

1로 만들기

정수 X가 주어질때 정수 X에 사용할 수 있는 연산은 다음과 같이 4가지이다.
1) X가 5로 나누어떨어지면, 5로 나눈다.
2) X가 3으로 나누어 떨어지면, 3으로 나눈다.
3) X가 2로 나누어 떨어지면, 2로 나눈다.
4) X에서 1을 뺀다.
정수 X가 주어졌을때, 연산 4개를 적절히 사용해서 1을 만들어야한다. 이 연산을 사용하는 횟수의 최솟값을 출력해라.

[입력]
26
[출력]
3

• dp[i] : i를 1로 만들기 위한 최소 연산 횟수

i에서 1을 빼면 i-1 이므로 dp[i-1] 에 1을 더해주면 된다. 또한 1을 빼는 연산을 제외하고 해당 수로 나누어떨어질 때에 한해 점화식을 적용할 수 있다.

dp[i] = min( dp[i-1], dp[i/2], dp[i/3], dp[i/5] ) + 1

 

👩🏻‍💻 소스코드

public class Main {

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

        int x = Integer.parseInt(br.readLine());

        for (int i = 2; i <= x; i++) {
            // 현재의 수에서 1을 빼는 경우
            dp[i] = dp[i - 1] + 1;

            if (i % 2 == 0)
                dp[i] = Math.min(dp[i], dp[i / 2] + 1);
            if (i % 3 == 0)
                dp[i] = Math.min(dp[i], dp[i / 3] + 1);
            if (i % 5 == 0)
                dp[i] = Math.min(dp[i], dp[i / 5] + 1);
        }

        System.out.println(dp[x]);

    }
}

---

효율적인 화폐 구성

N가지 종류의 화폐가 있다. 이 화폐들의 개수를 최소한으로 이용해서 그 가치의 합이 M원이 되도록 하려고 한다. 이때 각 화폐는 몇 개라도 사용할 수 있으며, 사용한 화폐의 구성은 같지만 순서만 다른 것은 같은 경우로 구분한다. 예를 들어 2원, 3원 단위의 화폐가 있을 때는 15원을 만들기 위해 3원을 5개 사용하는 것이 가장 최소한의 화폐 개수이다.

입력조건
첫째 줄에 N,M이 주어진다(1<= N <= 100, 1<= M <= 10,000)
이후의 N개의 줄에는 각 화폐의 가치가 주어진다. 화폐의 가치는 10,000보다 작거나 같은 자연수이다.
출력조건첫째 줄에 경우의 수 X를 출력한다.(불가능할 때는 -1을 출력한다)

[입력]
2 1523
[출력]
5

• dp[i] : 금액 i를 만들 수 있는 최소한의 화폐 개수
• k : 각 화폐의 단위

점화식은 각 화폐 단위인 k를 하나씩 확인하며 i-k원을 만드는 방법이 존재하는 경우와 만드는 방법이 존재하지 않은 경우로 나눌 수 있다.

dp[i] = min( dp[i], dp[i-k] + 1 ) ➜ i-k원을 만드는 방법이 존재하는 경우
dp[i] = -1 ➜ 존재하지 않는 경우

 

👩🏻‍💻 소스코드

public class Main {

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

        int N = Integer.parseInt(st.nextToken());
        int M = Integer.parseInt(st.nextToken());

        int[] arr = new int[N];
        for (int i = 0; i < N; i++) {
            arr[i] = Integer.parseInt(br.readLine());
        }

        int[] dp = new int[M + 1];
        Arrays.fill(dp, 10001);
        // M의 최대가 10000이므로 

        dp[0] = 0;
        for (int i = 0; i < N; i++) {
            for (int j = arr[i]; j <= M; j++) {
                if (dp[j - arr[i]] != 10001) {
                    dp[j] = Math.min(dp[j], dp[j - arr[i]] + 1);
                }
            }
        }
        if (dp[M] == 10001)
            System.out.println(-1);
        else
            System.out.println(dp[M]);

    }

---

금광

n x m 크기의 금광이 있습니다. 금광은 1 x 1 크기의 칸으로 나누어져 있으며, 각 칸은 특정한 크기의 금이 들어 있습니다. 채굴자는 첫 번째 열부터 출발하여 금을 캐기 시작합니다. 맨 처음에는 첫 번째 열의 어느 행에서든 출발할 수 있습니다. 이후에 m - 1번에 걸쳐서 매번 오른쪽 위, 오른쪽, 오른쪽 아래 3가지 중 하나의 위치로 이동해야 합니다. 결과적으로 채굴자가 얻을 수 있는 금의 최대 크기를 출력하는 프로그램을 작성하세요.

입력조건
첫째 줄에 n과 m이 공백으로 구분되어 입력된다. 둘째 줄에 n x m 개의 위치에 매장된 금의 개수가 공백으로 구분되어 입력된다. 

[입력]
3 4
1 3 3 2 2 1 4 1 0 6 4 7

[출력]
19

• dp[i][j] : i행 j열까지 얻을 수 있는 금의 최대값
• arr[i][j] : i행 j열에 존재하는 금의 양
  코드에서는 바로 DP 배열에 초기 데이터를 담은 후 갱신하는 방식으로 구현

왼쪽 위에서 오는 경우, 왼쪽 아래에서 오는 경우, 왼쪽에서 오는 경우 중 가장 많은 금을 가지고 있는 경우를 dp 배열에 갱신해주어 문제를 해결한다.

dp[i][j] = arr[i][j] + max( dp[i-1][j-1], dp[i][j-1], dp[i-1][j] )

 

👩🏻‍💻 소스코드

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

        int N = Integer.parseInt(st.nextToken());
        int M = Integer.parseInt(st.nextToken());
        int[][] dp = new int[N][M];
        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                dp[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        for (int j = 1; j < M; j++) {
            for (int i = 0; i < N; i++) {
                int leftUp, leftDown, left;

                if (i == 0) leftUp = 0;
                else leftUp = dp[i - 1][j - 1];

                if (i == N - 1) leftDown = 0;
                else leftDown = dp[i + 1][j - 1];

                left = dp[i][j - 1];

                dp[i][j] = dp[i][j] + Math.max(leftUp, Math.max(leftDown, left));
            }
        }

        int result = 0;
        for (int i = 0; i < N; i++) {
            result = Math.max(result, dp[i][M - 1]);
        }
        System.out.println(result);

    }
}