다이나믹 프로그래밍

• 다이나믹 프로그래밍이란?
  • 메모리를 적절히 사용하여 수행 시간 효율성을 비약적으로 향상시키는 방법
  • 이미 계산된 결과(작은 문제)는 별도의 메모리 영역에 저장하여 다시 계산하지 않도록 함
  • 다이나믹 프로그래밍의 구현은 일반적으로 두 가지 방식(탑다운/보텀업)으로 구성됨
• 다이나믹 프로그래밍은 문제가 다음의 조건을 만족할 때 사용할 수 있음
  1. 최적 부분 구조 (Optimal Substructure)
     • 큰 문제를 작은 문제로 나눌 수 있으며 작은 문제의 답을 모아서 큰 문제를 해결할 수 있음
  2. 중복되는 부분 문제 (Overlaping Subproblem)
     • 동일한 작은 문제를 반복적으로 해결

다이나믹 프로그래밍 방식

메모이제이션 (Memoization)

• 한 번 계산한 결과를 메모리 공간에 메모하는 기법을 메모이제이션이라고 부름
• 메모이제이션은 다이나믹 프로그래밍을 구현하는 방법 중 하나 (탑다운)
• 같은 문제를 다시 호출하면 메모했던 결과를 그대로 가져옴
• 값을 기록해 놓는다는 점에서 캐싱(Caching)이라고도 함
• 메모이제이션에서 값을 저장할 때 이용하는 배열의 이름으로 cash, memo, table, dp, d 등을 이용함

탑다운 (재귀 + 메모이제이션)

• 하향식이라고도 함
• 구현과정에서 재귀함수를 이용함
• 큰 문제를 해결하기 위해 작은 문제를 재귀적으로 호출하여 문제를 해결
  + 한 번 계산한 결과를 기록하기 위해 메모이제이션 활용

보텀업

• 상향식이라고도 함
• 아래쪽에서부터 문제를 해결함
• 먼저 계산한 값을 활용해 그 다음의 문제까지 차례대로 해결
• 재귀함수 대신 반복문을 이용함
• 다이나믹 프로그래밍의 전형적인 형태는 보텀업 방식 (탑다운은 재귀를 이용하기 때문에)

메모이제이션의 의미

• 엄밀히 말하면 메모이제이션은 이전에 계산된 결과를 일시적으로 기록해 놓는 넓은 개념을 의미함
  • 따라서 메모이제이션은 다이나믹 프로그래밍에 국한된 개념은 아님
  • 한 번 계산된 결과를 담아 놓기만 하고 다이나믹 프로그래밍을 위해 활용하지 않을 수도 있음
  • 메모이제이션과 다이나믹 프로그래밍은 엄밀히 말하면 다른 개념!
  • 즉 다이나믹 프로그래밍을 구현하는 방법 중에서 하향식으로 접근을 할 때, 이미 계산한 결과를 기록하는 용도로 메모이제이션을 활용함

피보나치 수열

1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 …
피보나치 수열은 다이나믹 프로그래밍으로 효과적으로 계산할 수 있음

점화식

• 점화식 : 인접한 항들 사이의 관계식
• 피보나치 수열의 점화식은 다음과 같고
  $a_n = a_{n-1} + a_{n-2}$
  $a_1$과 $a_2$를 알면 아무리 큰 수열이여도 구할 수 있음
  
• 프로그래밍에서 이러한 수열을 표현하려면 배열이나 리스트를 이용함
  • 배열이나 리스트 → 수열과 같은 선형적인 정보를 저장하는 역할
  • 별도로 테이블과 같은 공간에 값을 기록한다고 하여 배열이나 리스트를 ‘테이블’이라고 부르기도 함
• 4번째 피보나치 수열이 계산되는 과정을 그림으로 표현하면 다음과 같이 트리 형태가 됨 (f(n) : n번째 피보나치 수)
  

피보나치 수열 : 단순 재귀 소스코드 (Python)

def fibo(x):
	if x == 1 or x == 2:
		return 1
	return fibo(x-1) + fibo(x-2)

피보나치 수열 : 단순 재귀 소스코드 (Java)

import java.util.*;

public class Main {
	public static int fibo(int x){
		if (x == 1 || x == 2) {
			return 1;
		}
		return fibo(x - 1) + fibo(x - 2);
	}

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

피보나치 수열의 시간 복잡도 분석

• 단순 재귀 함수로 피보나치 수열을 해결하면 지수 시간 복잡도를 가지게 됨
• n이 조금만 커지면 시간이 급격히 늘어남
• 또한 동일한 함수가 반복적으로 호출 → 중복되는 부분 문제

• 재귀함수를 이용한 피보나치 수열의 시간 복잡도 : $O(2^N)$
• f(30)을 계산하기 위해 약 10억 가량의 연산을 수행해야 함

피보나치 수열의 효율적인 해법 : 다이나믹 프로그래밍

• 다이나믹 프로그래밍의 사용 조건을 만족하는지 확인
  1. 최적 부분 구조 : 큰 문제를 작은 문제로 나눌 수 있음
  2. 중복되는 부분 문제 : 동일한 작은 문제를 반복적으로 해결
• 피보나치 수열은 다이나믹 프로그래밍의 사용 조건을 만족

피보나치 수열 : 탑다운 다이나믹 프로그래밍 소스코드 (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))

피보나치 수열 : 보텀업 다이나믹 프로그래밍 소스코드 (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.uti.*;

public class Main {
	public static long[] d = new long[100];

	public static void main(String[] args){
		d[1] = 1;
		d[2] = 1;
		int n = 50;

		for (int i = 3; i <= n; i++){
			d[i] = d[i-1] + d[i-2];
		}

		System.out.println(d[n]);
	}
}

피보나치 수열 : 메모이제이션 동작 분석

• 이미 계산된 결과를 메모리에 저장하면 다음과 같이 색칠된 노드만 처리할 것을 기대할 수 있음

• 실제로 호출되는 함수에 대해서만 확인해보면 다음과 같이 방문
  

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

  • N의 값이 아무리 커진다고 하더라도, 메모리 공간을 n만큼 가질 수 있다면 충분히 선형시간 알고리즘으로 해결 가능

print문을 이용하여 메모이제이션을 이용하는 경우의 시간 복잡도 확인

d = [0] * 100

def fibo(x):
	print('f(' + str(x) + ')', end = ' ')

	if x == 1 or x == 2:
		return 1

	if d[x] != 0:
		return d[x]

	d[x] = fibo(x - 1) + fibo(x - 2)

fibo(6)

# 실행 결과 : f(6) f(5) f(4) f(3) f(2) f(1) f(2) f(3) f(4)

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

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

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

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

다이나믹 프로그래밍 문제

문제1 : 개미 전사

문제 해결 아이디어

• 문제에서 점화식을 뽑아낼 수 있어야 함
• 점화식 유도 $a_i$ = i 번째 식량 창고까지의 최적의 해, $k_i$ = i번째 식량창고의 식량의 양 이라고 하면 $a_i$는 $a_{i-1}$과 $a_{i-2} + k_i$ 중 더 큰 값이 된다. 따라서
  $a_i = max(a_{i-1}, a_{i-2}+k)$

솔루션 코드

# 개미 전사

# 입력
n = int(input())
array = list(map(int, input().split()))

# DP 테이블
d = [0] * 100

# 다이나믹 프로그래밍 진행(보텀업)
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])

문제2 : 1로 만들기

문제 해결 아이디어

• X가 6인 경우 연산의 최솟값은 아래 세가지 경우 중 최솟값으로 결정됨
  1. X가 5인 경우 연산의 최솟값 + 1
  2. X가 3인 경우 연산의 최솟값 + 1
  3. X가 2인 경우 연산의 최솟값 + 1
• 이런식으로 재귀 함수의 호출 형태를 띄게 구현할 수 있음 → 이럴 경우 탑다운 방식의 다이나믹 프로그래밍이 효율적으로 동작 가능
• 그리디 문제와의 차이점?
  • 그리디 문제의 경우 어떤 수이든 나누는 것이 빼는 것보다 최적의 해를 만들어주는 연산이기 때문에 나누는 연산을 항상 우선으로 실행하면 되었음
  • 하지만 위 문제는 무조건 큰 수로 나눈다고 최적의 해를 가지게 되는 것이 아님. 따라서 그리디 알고리즘으로 해결할 수 없는 문제
  • 작은 문제들로 나뉘어 최적 부분 구조와 중복되는 부분 문제에 해당됨

# 1로 만들기

# 입력
x = int(input())

# dp 테이블
d = [0] * 30001

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

print(d[x])

문제3 : 효율적인 화폐 구성

문제 해결 아이디어

• 금액 i에서의 최소한의 화폐 개수는 금액 i에서 화폐 단위 하나를 뺀 것 만큼의 금액에서의 최소한의 화폐 개수를 통해 구할 수 있다.
  • 보텀업 방식으로 구현하면 M+1 크기의 dp 테이블을 만들어 $a_i$를 기록해야 한다.
  • dp 테이블에서 N개의 각 화폐 단위를 하나씩 확인하며 값을 기록한다.

솔루션 코드 1 (강의 풀이) : 각 화폐 단위를 하나씩 확인하며

# 효율적인 화폐 구성

# 입력
n, m = map(int, input().split())
array = []
for i in range(n):
    array.append(int(input()))

# dp 테이블
d = [10001] * (m + 1)

# 다이나믹 프로그래밍 보텀업
d[0] = 0
for i in range(n):
    for j in range(array[i], m + 1):
        if d[j - array[i]] != 10001:
            d[j] = min(d[j], d[j - array[i]] + 1)

# 출력
if d[m] == 10001:
    print(-1)
else:
    print(d[m])

솔루션 코드 2 : 모든 비용을 하나씩 확인하며

# 효율적인 화폐 구성 2

# 입력
n, m = map(int, input().split())
array = []
for i in range(n):
    array.append(int(input()))

# dp 테이블
d = [10001] * (m + 1)
d[0] = 0

# 다이나믹 프로그래밍 진행 (보텀업)
for i in range(1, m + 1):
    for k in array:
        if i - k >= 0:
            d[i] = min(d[i], d[i - k] + 1)

if d[m] > 10000:
    print(-1)
else:
    print(d[m])

문제 4 : 금광

문제 해결 아이디어

# 금광

t = int(input())

for _ in range(t):
    # 입력
    n, m = map(int, input().split()) # n x m 금광
    array = list(map(int, input().split())) # 각 칸의 매장량
    
    # dp 테이블 초기화
    dp = []
    index = 0
    for i in range(n):
        dp.append(array[index:index + m])
        index += m
    
    # m개의 각 열에 대하여 보텀업 다이나믹 프로그래밍 진행
    # 0열은 그대로, 1열부터 시작
    for j in range(1, m):
        for i in range(n):
            # 1. 왼쪽 위에서 오는 경우 : left_up
            if i == 0:
                left_up = -1 # 맨 위의 행이면 존재하지 않음
            else:
                left_up = dp[i - 1][j - 1]
            # 2. 왼쪽에서 오는 경우 : left
            left = dp[i][j - 1]
            # 3. 왼쪽 아래에서 오는 경우 : left_down
            if i == n - 1:
                left_down = -1 # 맨 아래의 행이면 존재하지 않음
            else:
                left_down = dp[i + 1][j - 1]
            # left_up, left, left_down 중 가장 큰 것을 선택하여 d[i][j] 갱신
            dp[i][j] = dp[i][j] + max(left_up, left_down, left)
    
    # 결과 출력 : 마지막 열 중 가장 큰 값
    result = -1
    for i in range(n):
        result = max(result, dp[i][m - 1])
    print(result)

문제5 : 병사 배치하기

문제 해결 아이디어

• 이 문제의 기본 아이디어는 가장 긴 증가하는 부분 수열(Longest Increasing Subsequence, LIS)로 알려진 전형적인 다이나믹 프로그래밍 문제의 아이디어와 같음
  

  • 현재 원소보다 더 작은 원소인 array[j]를 마지막 원소로 가지는 D[j]에 하나를 추가한 값과, 현재 D[i]를 비교해서 더 큰 값이 선택되도록 하면 됨

    

• 해당 문제는 ‘감소하는 수열’을 구해야 하므로 입력받은 병사 정보의 순서를 뒤집고 LIS 알고리즘을 수행하여 정답을 도출해야 함

솔루션 코드

# 병사 배치하기

# 입력
n = int(input())
array = list(map(int, input().split()))
array.reverse()

# 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))

백준 문제

1436번 : 1로 만들기

1463번: 1로 만들기

문제 풀이 아이디어

솔루션 코드

# 1로 만들기

# 입력
x = int(input())

dp = [0] * (10**6 + 1)

# dp 테이블 채우기
for i in range(2, x + 1):
    # 1. 현재의 수에서 1을 빼는 경우
    dp[i] = dp[i - 1] + 1
    # 2. 현재의 수가 2로 나누어 떨어지는 경우
    if i % 2 == 0:
        dp[i] = min(dp[i], dp[i // 2] + 1)
    # 3. 현재의 수가 3으로 나누어 떨어지는 경우
    if i % 3 == 0:
        dp[i] = min(dp[i], dp[i // 3] + 1)

print(dp[x])

11053번 : 가장 긴 증가하는 부분 수열

11053번: 가장 긴 증가하는 부분 수열

문제 풀이 아이디어

• D[i] : array[i]를 마지막 원소로 가지는 부분 수열의 최대 길이
• 0 ≤ j < i이고, array[j] < array[i]인 모든 j에 대하여
• D[i] = max(D[i], D[j] + 1)

솔루션 코드

# 가장 긴 증가하는 부분수열

# 입력
n = int(input())
array = list(map(int, input().split()))

# 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(max(dp))

9095번 : 1, 2, 3 더하기

9095번: 1, 2, 3 더하기

문제 풀이 아이디어

i > 3

솔루션 코드

# 1, 2, 3 더하기

dp = [0] * 11
dp[1] = 1
dp[2] = 2
dp[3] = 4

for tc in range(int(input())):
    # 입력
    n = int(input())
    # 다이나믹 프로그래밍
    for i in range(4, n+1):
        dp[i] = dp[i-1] + dp[i-2] + dp[i-3]
    # 출력
    print(dp[n])

2775번 : 부녀회장이 될테야

2775번: 부녀회장이 될테야

문제 풀이 아이디어

• dp 테이블
  • i층 j호에 거주하는 거주민의 수를 dp[i][j]로 가지는 2차원 배열을 dp 테이블로 만든다
• 점화식

  • 아파트 거주 조건을 만족하려면 dp 테이블에 들어가는 수는 다음과 같은 점화식을 만족시킨다.

    $dp[i][j] = dp[i][j-1] + dp[i-1][j]$
• dp 테이블 초기화

  • n과 k의 최대값이 14이기 때문에 15*15 크기의 2차원 배열을 이용한다.

  • 0층의 i호에는 i명이 산다고 문제에 제시되어 있기 때문에 0층(0행)을 미리 초기화 시켜줄 수 있다.

  • 모든 층의 1호에는 1명이 살고 있을 것이기 때문에 1층(0열)을 미리 초기화 시켜줄 수 있다.

    	1호	2호	3호	…	14호
    14층	1명	?	?	…	?
    …	…	…	…	…	…
    2층	1명	1+1+2	(1+1+2)+1+2+3	…	?
    1층	1명	1+2	(1+2)+3	…	?
    0층	1명	2명	3명	…	14명

솔루션 코드

# 부녀회장이 될테야

# dp 테이블
dp = [[0]*15 for _ in range(15)]
# 0층 초기화
dp[0] = [x for x in range(0, 15)]
# 1호 초기화
for i in range(15):
    dp[i][1] = 1

for tc in range(int(input())):
    # 입력
    k = int(input())
    n = int(input())
    # k층 n호까지 다이나믹 프로그래밍 실행
    for i in range(1, k + 1):
        for j in range(2, n + 1):
            dp[i][j] = dp[i][j-1] + dp[i - 1][j]
    # 출력
    print(dp[k][n])

출처 : https://youtu.be/5Lu34WIx2Us