출처 : https://www.youtube.com/watch?v=5Lu34WIx2Us&list=PLRx0vPvlEmdAghTr5mXQxGpHjWqSz0dgC&index=6

📌 다이나믹 프로그래밍

• 다이나믹 프로그래밍은 메모리를 적절히 사용하여 수행 시간 효율성을 비약적으로 향상시키는 방법
• 이미 계산된 결과(작은 문제)는 별도의 메모리 영역에 저장하여 다시 계산하지 않도록 함
• 다이나믹 프로그래밍의 구현은 일반적으로 두 가지 방식
  탑다운(위 ➡️ 아래)과 보텀업(아래 ➡️ 위)으로 구성된다.
• 다이나믹 프로그래밍은 동적계획법이라고도 불린다.
  
  

탑다운 VS 보텀업

• 탑다운(메모이제이션) 방식은 하향식이라고도 하며 보텀업 방식은 상향식이라고도 한다.
• 다이나믹 프로그래밍의 전형적인 형태는 보텀업 방식
• 결과 저장용 리스트는 DP 테이블이라고 부른다.

🤔 다이나믹 프로그래밍의 조건

1. 최적 부분 구조 (Optimal Substructure)
👉🏻 큰 문제를 작은 문제로 나눌 수 있으며 작은 문제의 답을 모아서 큰 문제를 해결할 수 있다.

2. 중복되는 부분 문제 (Overlapping Subproblem)
👉🏻 동일한 작은 문제를 반복적으로 해결해야 한다.

🤓 다이나믹 프로그래밍을 활용하여 해결할 수 있는 문제 : 피보나치 수열

피보나치 수열을 점화식(인접한 항들 사이의 관계식)으로 표현하면 아래과 같다.

👉🏻 프로그래밍에서는 이러한 수열을 배열이나 리스트를 이용해 표현

피보나치 수열이 계산되는 과정은 아래와 같이 표현할 수 있다.

🤯 시간 복잡도 분석

✅ 단순 재귀 함수로 피보나치 수열을 해결하면 지수 시간 복잡도를 가지게 된다.
✅ n이 조금만 커져도 기하급수적으로 많은 시간이 필요함
✅ 다음과 같이 f(2)가 여러 번 호출되는 것을 확인할 수 있다. (중복되는 부분 문제)

✅ 피보나치 수열의 시간 복잡도는 아래와 같다.

빅오 표기법을 기준으로 f(30)을 계산하기 위해 약 10억가량의 연산을 수행해야 한다. 그렇다면 f(100)을 계산하기 위해 얼마나 많은 연산을 수행해야 할까 ❓
👉🏻 f(30)과는 비교도 안되게 많은 연산을 해야할 것이다.

먼저, 피보나치 수열이 다이나믹 프로그래밍의 사용 조건을 만족하는지 확인한다.

1. `최적 부분 구조` : 큰 문제를 작은 문제로 나눌 수 있습니다.
2. `중복되는 부분 문제` : 동일한 작은 문제를 반복적으로 해결합니다.

👉🏻 피보나치 수열은 다이나믹 프로그래밍의 사용 조건을 만족합니다.

✏️ [탑다운] 메모이제이션 (Memoization)

• 메모이제이션은 다이나믹 프로그래밍을 구현하는 방법 중 하나입니다.
• 한 번 계산한 결과를 메모리 공간에 메모하는 기법입니다.
• 같은 문제를 다시 호출하면 메모했던 결과를 그대로 가져옵니다.
• 값을 기록해 놓는다는 점에서 캐싱(Caching)이라고도 합니다.
  
  

엄밀히 말하면 메모이제이션은 의전에 계산된 결과를 일시적으로 기록해 놓는 넓은 개념을 의미한다. 따라서 메모이제이션은 다이나믹 프로그래밍에 국한된 개념은 아니다. 한 번 계산된 결과를 담아 놓기만 하고 다이나믹 프로그래밍을 위해 활용하지 않을 수도 있다.
👉🏻 따라서 메모이제이션과 다이나믹 프로그래밍은 같은 개념이 아니다!

[탑다운] 메모이제이션 (Memoization) 소스코드

python

# 한 번 계산된 결과를 메모이제이션(Memoization)하기 위한 리스트 초기화
d = [0] * 100

# 피보나치 함수(Fibonacci Function)를 재귀함수로 구현 (탑다운 다이나믹 프로그래밍)
def fibo(x):
    # 종료 조건(1 혹은 2일 때 1을 반환)
    if x == 1 or x == 2:
        return 1
    # 이미 계산한 적 있는 문제라면 그대로 반환
    if d[x] != 0:
        return d[x]
    # 아직 계산하지 않은 문제라면 점화식에 따라서 피보나치 결과 반환
    d[x] = fibo(x - 1) + fibo(x - 2)
    return d[x]

print(fibo(99))

Java

import java.util.*;

public class Main {

    // 한 번 계산된 결과를 메모이제이션(Memoization)하기 위한 배열 초기화
    public static long[] d = new long[100];

    // 피보나치 함수(Fibonacci Function)를 재귀함수로 구현 (탑다운 다이나믹 프로그래밍)
    public static long fibo(int x) {
        // 종료 조건(1 혹은 2일 때 1을 반환)
        if (x == 1 || x == 2) {
            return 1;
        }
        // 이미 계산한 적 있는 문제라면 그대로 반환
        if (d[x] != 0) {
            return d[x];
        }
        // 아직 계산하지 않은 문제라면 점화식에 따라서 피보나치 결과 반환
        d[x] = fibo(x - 1) + fibo(x - 2);
        return d[x];
    }

    public static void main(String[] args) {
        System.out.println(fibo(50));
    }
}

🤯 시간 복잡도 분석

메모이제이션을 이용하는 경우 피보나치 수열 함수의 시간 복잡도는 0(N)이다.

[보텀업] 다이나믹 프로그래밍 소스코드

python

# 앞서 계산된 결과를 저장하기 위한 DP 테이블 초기화
d = [0] * 100

# 첫 번째 피보나치 수와 두 번째 피보나치 수는 1
d[1] = 1
d[2] = 1
n = 99

# 피보나치 함수(Fibonacci Function) 반복문으로 구현(보텀업 다이나믹 프로그래밍)
for i in range(3, n + 1):
    d[i] = d[i - 1] + d[i - 2]

print(d[n])

Java

import java.util.*;

public class Main {

    public static long[] d = new long[100];

    public static void main(String[] args) {
        // 첫 번째 피보나치 수와 두 번째 피보나치 수는 1
        d[1] = 1;
        d[2] = 1;
        int n = 50; // 50번째 피보나치 수를 계산

        // 피보나치 함수(Fibonacci Function) 반복문으로 구현(보텀업 다이나믹 프로그래밍)
        for (int i = 3; i <= n; i++) {
            d[i] = d[i - 1] + d[i - 2];
        }
        System.out.println(d[n]);
    }
}

🤗 다이나믹 프로그래밍 vs 분할 정복

• 다이나믹 프로그래밍과 분할 정복은 모두 최적 부분 구조를 가질 때 사용할 수 있습니다.
  최적 부분 구조 : 큰 문제를 작은 문제로 나눌 수 있으며 작은 문제의 답을 모아서 큰 문제를 해결할 수 있는 상황
• 다이나믹 프로그래밍과 분할 정복의 차이점은 부분 문제의 중복 입니다.
  ✅ 다이나믹 프로그래밍 문제에서는 각 부분 문제들이 서로 영향을 미치며 부분 문제가 중복됩니다.
  ✅ 분할 정복 문제에서는 동일한 부분 문제가 반복적으로 계산되지 않습니다.
  
  
  

분할 정복의 대표적인 예시인 퀵 정렬을 살펴보자

• 한 번 기준 원소(Pivot)가 자리를 변경해서 자리를 잡으면 그 기준 원소의 위치는 바뀌지 않는다.
• 분할 이후에 해당 피벗을 다시 처리하는 부분 문제는 호출하지 않는다.

✏️ 다이나믹 프로그래밍 문제에 접근하는 방법

• 주어진 문제가 다이나믹 프로그래밍 유형임을 파악하는 것이 중요
• 가장 먼저 그리디, 구현, 완전 탐색 등의 아이디어로 문제를 해결할 수 있는지 검토해보고 풀이 방법이 떠오르지 않으면 다이나믹 프로그래밍을 고려해 보자
• 일단 재귀 함수로 비효율적인 완전 탐색 프로그램을 작성한 뒤에 (탑다운) 작은 문제에서 구한 답이 큰 문제에서 그대로 사용될 수 있으면, 코드를 개선하는 방법을 사용할 수 있다.
• 일반적인 코딩 테스트 수준에서는 기본 유형의 다이나믹 프로그래밍 문제가 출제되는 경우가 많다.

✔️ [실습] 개미전사 🐜 : 최적 부분 구조, 보텀업

---

a, = 1번째 식량창고까지의 최적의 해 (얻을 수 있는 식량의 최댓값)이라고 정의한다면 다이나믹 프로그래밍을 적용할 수 있다.

왼쪽부터 차례대로 식량창고를 턴다고 했을 때, 특정한 번째의 식량창고에 대해서 털지 안 털지의 여부를 결정하면, 아래 2가지 경우 중에서 더 많은 식량을 털 수 있는 경우를 선택하면 된다.

이를 수식으로 표현하면

점화식은 아래와 같다
👉🏻 i번째 까지 얻을 수 있는 식량의 최대값은 i-1번째까지의 최대값과 i-2번째까지의 최대값 + 현재 창고의 식량값 중 더 큰 값이다.

한 칸 이상 떨어진 식량창고는 항상 털 수 있으므로 (i - 3)번째 이하는 고려할 필요가 없다.

---

python

# 정수 N을 입력 받기
n = int(input())
# 모든 식량 정보 입력 받기
array = list(map(int, input().split()))

# 앞서 계산된 결과를 저장하기 위한 DP 테이블 초기화
d = [0] * 100 # n은 최대 100까지 들어올 수 있다했으므로

# 다이나믹 프로그래밍(Dynamic Programming) 진행 (보텀업)
d[0] = array[0]
d[1] = max(array[0], array[1]) 
for i in range(2, n):
    d[i] = max(d[i - 1], d[i - 2] + array[i])

# 계산된 결과 출력
print(d[n - 1])

Java

import java.util.*;

public class Main {

    // 앞서 계산된 결과를 저장하기 위한 DP 테이블 초기화 
    public static int[] d = new int[100];

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // 정수 N을 입력받기
        int n = sc.nextInt();

        // 모든 식량 정보 입력받기
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextInt();
        }

        // 다이나믹 프로그래밍(Dynamic Programming) 진행(보텀업)
        d[0] = arr[0];
        d[1] = Math.max(arr[0], arr[1]);
        for (int i = 2; i < n; i++) {
            d[i] = Math.max(d[i - 1], d[i - 2] + arr[i]);
        }

        // 계산된 결과 출력
        System.out.println(d[n - 1]);
    }
}

✔️ [실습] 1로 만들기 : 최적 부분 구조, 중복되는 부분 문제, 보텀업

• X가 30000까지이므로 당연히 DP 사용!!
• 완전 탐색 실습 문제에서의 1이 될 때까지와는 다르다. 단순히 큰 값으로 나눈다고 연산 횟수가 최소가 되진 않기 때문
• 따라서 이 문제는 작은 문제를 조합하여 큰 문제를 해결하기 때문에 최적 부분 구조를 만족한다.

---

피보나치 수열 문제를 도식화한 것처럼 함수가 호출되는 과정을 그림으로 그려보면 아래과 같다.
✅ 최적 부분 구조와 중복되는 부분 문제를 만족한다.

예를 들어 x가 6일 때는 6에서 1을 뺀 f(5)에서의 최적의 해, 6에서 2를 나눈 f(3)에서의 최적의 해, 6에서 3을 나눈 f(2)에서의 최적의 해 중에서 가장 작은 값을 골라 f(6)일 때의 최적의 해를 구할 수 있다.

다만 여기서 6은 5로 나누어떨어지지 않기 때문에 5로 나누는 경우는 고려하지 않았다.

i번째 a = i를 1로 만들기 위한 최소 연산 횟수라고 정의 했을 때, 점화식은 아래와 같다.

단, 1을 빼는 연산을 제외하고는 해당 수로 나누어떨어질 때에 한해 점화식을 적용할 수 있다.

python

# 정수 X를 입력 받기
x = int(input())

# 앞서 계산된 결과를 저장하기 위한 DP 테이블 초기화
d = [0] * 1000001

# 다이나믹 프로그래밍(Dynamic Programming) 진행(보텀업)
for i in range(2, x + 1):
    # 현재의 수에서 1을 빼는 경우
    d[i] = d[i - 1] + 1
    # 현재의 수가 2로 나누어 떨어지는 경우
    if i % 2 == 0:
        d[i] = min(d[i], d[i // 2] + 1)
    # 현재의 수가 3으로 나누어 떨어지는 경우
    if i % 3 == 0:
        d[i] = min(d[i], d[i // 3] + 1)
    # 현재의 수가 5로 나누어 떨어지는 경우
    if i % 5 == 0:
        d[i] = min(d[i], d[i // 5] + 1)

print(d[x])

python(짜왕.ver)

x = int(input())
dp = [0] * (x + 1)

for i in range(2, x + 1):
    arr = []
    if i % 2 == 0:
        arr.append(dp[i//2])
    if i % 3 == 0:
        arr.append(dp[i//3])
    if i % 5 == 0:
        arr.append(dp[i//5])
    arr.append(dp[i-1])
    dp[i] = int(min(arr)) + 1

print(dp[x])

Java

import java.util.*;

public class Main {

    // 앞서 계산된 결과를 저장하기 위한 DP 테이블 초기화 
    public static int[] d = new int[30001];

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int x = sc.nextInt();

        // 다이나믹 프로그래밍(Dynamic Programming) 진행(보텀업)
        for (int i = 2; i <= x; i++) {
            // 현재의 수에서 1을 빼는 경우
            d[i] = d[i - 1] + 1;
            // 현재의 수가 2로 나누어 떨어지는 경우
            if (i % 2 == 0)
                d[i] = Math.min(d[i], d[i / 2] + 1);
            // 현재의 수가 3으로 나누어 떨어지는 경우
            if (i % 3 == 0)
                d[i] = Math.min(d[i], d[i / 3] + 1);
            // 현재의 수가 5로 나누어 떨어지는 경우
            if (i % 5 == 0)
                d[i] = Math.min(d[i], d[i / 5] + 1);
        }
        System.out.println(d[x]);
    }
}

✔️ [실습] 효율적인 화폐 구성 : 보텀업

---

문제 해결 아이디어

N = 3, M = 7이고, 각 화폐의 단위가 2, 3, 5인 경우를 확인해 보자

1️⃣ [Step 1 (초기화)]

• 먼저 각 인덱스에 해당하는 값으로 INF(무한)의 값을 설정
• INF은 특정 금액을 만들 수 있는 화폐 구성이 가능하지 않다는 의미를 가진다.
• 본 문제에서는 10,001을 사용할 수 있다. (M의 최대값이 10000이므로)
  

2️⃣ [Step 2]

• 첫 번째 화폐 단위인 2를 확인
• 점화식에 따라서 다음과 같이 리스트가 갱신된다.
  

3️⃣ [Step 3]

• 두 번째 화폐 단위인 3를 확인
• 점화식에 따라서 다음과 같이 리스트가 갱신된다.
  

4️⃣ [Step 4]

• 세 번째 화폐 단위인 5를 확인
• 점화식에 따라서 다음과 같이 최종적으로 리스트가 갱신된다.
  

python

# 정수 N, M을 입력 받기
n, m = map(int, input().split())
# N개의 화폐 단위 정보를 입력 받기
array = []
for i in range(n):
    array.append(int(input()))

# 한 번 계산된 결과를 저장하기 위한 DP 테이블 초기화
d = [10001] * (m + 1)

# 다이나믹 프로그래밍(Dynamic Programming) 진행(보텀업)
d[0] = 0
for i in range(n):  # i = 화폐 단위
    for j in range(array[i], m + 1):  # j = 금액
        if d[j - array[i]] != 10001: # (i - k)원을 만드는 방법이 존재하는 경우
            d[j] = min(d[j], d[j - array[i]] + 1)

# 계산된 결과 출력
if d[m] == 10001: # 최종적으로 M원을 만드는 방법이 없는 경우
    print(-1)
else:
    print(d[m])

Java

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // 정수 N, M을 입력받기
        int n = sc.nextInt();
        int m = sc.nextInt();

        // N개의 화폐 단위 정보를 입력 받기
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextInt();
        }

        // 앞서 계산된 결과를 저장하기 위한 DP 테이블 초기화 
        int[] d = new int[m + 1];
        Arrays.fill(d, 10001);

        // 다이나믹 프로그래밍(Dynamic Programming) 진행(보텀업)
        d[0] = 0;
        for (int i = 0; i < n; i++) {
            for (int j = arr[i]; j <= m; j++) {
                // (i - k)원을 만드는 방법이 존재하는 경우
                if (d[j - arr[i]] != 10001) {
                    d[j] = Math.min(d[j], d[j - arr[i]] + 1);
                }
            }
        }

        // 계산된 결과 출력
        if (d[m] == 10001) { // 최종적으로 M원을 만드는 방법이 없는 경우
            System.out.println(-1);
        }
        else {
            System.out.println(d[m]);
        }
    }
}

✔️ [실습] 금광 : 보텀업

---

문제 해결 아이디어

• 금광의 모든 위치에 대하여 다음의 세 가지만 고려하면 된다.
  1. 왼쪽 위에서 오는 경우
  2. 왼쪽 아래에서 오는 경우
  3. 왼쪽에서 오는 경우
• 세 가지 경우 중에서 가장 많은 금을 가지고 있는 경우를 테이블에 갱신해주어 문제를 해결합니다.
  

• array[i][j] = i행 j열에 존재하는 금의 양
• dp[i][j] = i행 j열까지의 최적의 해 (얻을 수 있는 금의 최댓값)

• 점화식은 아래와 같다.

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

• 이때 테이블에 접근할 때마다 리스트의 범위를 벗어나지 않는지 체크해야 한다.

• 편의상 초기 데이터를 담는 변수 array를 사용하지 않고 바로 DP 테이블에 초기 데이터를 담아서 다이나믹 프로그래밍을 적용할 수 있다.

---

해결 과정

---

python

# 테스트 케이스(Test Case) 입력
for tc in range(int(input())):
    # 금광 정보 입력
    n, m = map(int, input().split())
    array = list(map(int, input().split()))

    # 다이나믹 프로그래밍을 위한 2차원 DP 테이블 초기화
    dp = []
    index = 0
    for i in range(n):
    	# 0 ~ 3, 4 ~ 7 이렇게 슬라이싱 하여 DP 초기화
        dp.append(array[index:index + m])
        index += m  # 4, 8, 12 이렇게 증가

    # 다이나믹 프로그래밍 진행
    for j in range(1, m):
        for i in range(n):
            # 왼쪽 위에서 오는 경우
            if i == 0:  # 인덱스 벗어난 경우
                left_up = 0 
            else:
                left_up = dp[i - 1][j - 1]
            # 왼쪽 아래에서 오는 경우
            if i == n - 1:  # 인덱스 벗어난 경우
                left_down = 0
            else:
                left_down = dp[i + 1][j - 1]
            # 왼쪽에서 오는 경우
            left = dp[i][j - 1]
            dp[i][j] = dp[i][j] + max(left_up, left_down, left)

    result = 0
    # 마지막 행의 열(가장 오른쪽 열) 중 최대값 고르기
    for i in range(n):
        result = max(result, dp[i][m - 1])

    print(result)

Java

import java.util.*;

public class Main {

    static int testCase, n, m;
    static int[][] arr = new int[20][20];
    static int[][] dp = new int[20][20];

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // 테스트 케이스(Test Case) 입력
        testCase = sc.nextInt();
        for (int tc = 0; tc < testCase; tc++) {
            // 금광 정보 입력
            n = sc.nextInt();
            m = sc.nextInt();
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    arr[i][j] = sc.nextInt();
                }
            }
            // 다이나믹 프로그래밍을 위한 2차원 DP 테이블 초기화
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    dp[i][j] = arr[i][j];
                }
            }
            // 다이나믹 프로그래밍 진행
            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);
        }
    }
}

✔️ [실습] 병사 배치하기

---

문제 해결 아이디어

• 이 문제의 기본 아이디어는 가장 긴 증가하는 부분 수열(Longest Increasing Subsequence, LIS)로 알려진 전형적인 다이나믹 프로그래밍 문제의 아이디어다.
• 예를 들어 하나의 수열 array = {4, 2, 5, 8, 4, 11, 15}이 있다고 하자.
  ✅ 이 수열의 가장 긴 증가하는 부분 수열은 {4, 5, 8, 11, 15}이다.
  ✅ 본 문제는 가장 긴 감소하는 부분 수열을 찾는 문제로 치환할 수 있으므로, LIS 알고리즘을 조금 수정하여 적용함으로써 정답을 도출할 수 있다.

가장 긴 증가하는 부분 수열(Longest Increasing Subsequence, LIS)

D[i] = array[i]를 마지막 원소로 가지는 부분 수열의 최대 길이

점화식은 아래와 같다.

---

문제 해결 과정

---

가장 먼저 입력 받은 병사 정보의 순서를 뒤집는다.
가장 긴 증가하는 부분 수열 (LIS) 알고리즘을 수행하여 정답을 도출한다.

python

n = int(input())
array = list(map(int, input().split()))
# 순서를 뒤집어 '최장 증가 부분 수열' 문제로 변환
array.reverse()

# 다이나믹 프로그래밍을 위한 1차원 DP 테이블 초기화
dp = [1] * n

# 가장 긴 증가하는 부분 수열(LIS) 알고리즘 수행
for i in range(1, n):
    for j in range(0, i):
        if array[j] < array[i]:
            dp[i] = max(dp[i], dp[j] + 1)

# 열외해야 하는 병사의 최소 수를 출력
print(n - max(dp))

Java

import java.util.*;

public class Main {

    static int n;
    static ArrayList<Integer> v = new ArrayList<Integer>();
    static int[] dp = new int[2000];

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();

        for (int i = 0; i < n; i++) {
            v.add(sc.nextInt());
        }

        // 순서를 뒤집어 '최장 증가 부분 수열' 문제로 변환
        Collections.reverse(v);

        // 다이나믹 프로그래밍을 위한 1차원 DP 테이블 초기화
        for (int i = 0; i < n; i++) {
            dp[i] = 1;
        }

        // 가장 긴 증가하는 부분 수열(LIS) 알고리즘 수행
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (v.get(j) < v.get(i)) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
        }

        // 열외해야 하는 병사의 최소 수를 출력
        int maxValue = 0;
        for (int i = 0; i < n; i++) {
            maxValue = Math.max(maxValue, dp[i]);
        }
        System.out.println(n - maxValue);
    }
}