1. 머리말

프로그래밍이나 알고리즘 학습을 진행하다 보면, 많은 학습자가 직면하는 큰 벽이 있습니다. 그것이 바로 동적 계획법 (Dynamic Programming, 줄여서 DP )입니다. 이름만 들으면 “왠지 어려울 것 같다”, “수학적 전문 지식이 필요한 것 아닌가?” 하고 긴장할지도 모릅니다. 하지만 본질을 이해하면, DP는 매우 강력하고 직관적인 문제 해결 기법임을 알 수 있습니다.

본 기사에서는 DP의 기본 개념에서 출발하여, 대표적인 문제인 “피보나치 수열"과 “배낭 문제"를 예로 들어 그 사고방식과 구현 방법을 철저하게 해설합니다. Python 코드를 섞어가며 단계적으로 이해를 넓혀가 봅시다.

2. 동적 계획법(DP)이란 무엇인가?

동적 계획법(Dynamic Programming)은 복잡한 문제를 여러 작은 부분 문제로 분할하고, 각각의 부분 문제에 대한 해를 기록(메모)하면서 풀어나가는 기법입니다. 이를 통해 동일한 계산을 반복하는 낭비를 줄이고, 계산 시간을 극적으로 단축할 수 있습니다.

DP의 핵심은 다음 2가지 특징에 있습니다.

부분 구조 최적성 (Optimal Substructure): 큰 문제의 최적해가 그 작은 부분 문제들의 최적해로 구성될 수 있다는 성질.
부분 문제의 중복 (Overlapping Subproblems): 동일한 작은 문제가 여러 번 반복해서 나타나는 성질.

이러한 특징을 가진 문제에 대해 DP는 엄청난 위력을 발휘합니다.

DP의 2가지 접근법

DP에는 크게 나누어 2가지 구현 접근법이 있습니다.

1. 메모이제이션 재귀 (탑다운 방식)

큰 문제에서 출발하여 재귀적으로 작은 문제를 호출합니다. 이때 한 번 계산한 결과를 배열이나 해시 맵에 저장(메모)해 두고, 같은 문제가 다시 나타났을 때는 재계산하지 않고 메모한 값을 반환합니다.

2. 바텀업 방식 (분할 정복과 테이블 채우기)

가장 작은 문제부터 순서대로 해를 계산하여 배열(DP 테이블)에 기록해 나갑니다. 작은 문제의 해를 사용하여 점차 큰 문제를 풀고, 최종적으로 구하고자 하는 문제의 해를 얻습니다.

3. 기초편: 피보나치 수열로 배우는 DP

DP의 개념을 이해하기 위한 첫걸음으로 피보나치 수열을 다루겠습니다.

피보나치 수열은 다음과 같이 정의되는 수열입니다. $ F(0) = 0 $ $ F(1) = 1 $ $ F(n) = F(n-1) + F(n-2) \quad \text{에 대해 } n \ge 2 $

3.1 단순한 재귀 호출의 함정

정의대로 Python으로 함수를 작성해 봅시다.

1
2
3
4
5
6
def fib_recursive(n):
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    return fib_recursive(n-1) + fib_recursive(n-2)

이 구현은 직관적이지만 큰 문제가 있습니다. 그것은 바로 계산량이 지수 함수적으로 증대한다 는 것입니다. $F(5)$ 를 계산할 때의 함수 호출 트리를 살펴봅시다.

  graph TD
    A["F(5)"] --> B["F(4)"]
    A --> C["F(3)"]
    B --> D["F(3)"]
    B --> E["F(2)"]
    C --> F["F(2)"]
    C --> G["F(1)"]
    D --> H["F(2)"]
    D --> I["F(1)"]
    E --> J["F(1)"]
    E --> K["F(0)"]
    F --> L["F(1)"]
    F --> M["F(0)"]
    H --> N["F(1)"]
    H --> O["F(0)"]

보시다시피 $F(3)$ 이나 $F(2)$ 가 여러 번 중복해서 계산되고 있습니다. 계산량은 $O(2^n)$ 이 되며, $n$ 이 커지면 실용적인 시간 안에 계산이 끝나지 않게 됩니다.

3.2 메모이제이션 재귀 (탑다운 방식)

이러한 낭비를 없애는 것이 메모이제이션 입니다. 한 번 계산한 결과를 저장해 둡시다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def fib_memo(n, memo=None):
    if memo is None:
        memo = {}
    if n in memo:
        return memo[n]
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    
    memo[n] = fib_memo(n-1, memo) + fib_memo(n-2, memo)
    return memo[n]

이로 인해 각 $F(i)$ 는 한 번만 계산하게 되어, 계산량은 $O(n)$ 으로 급감합니다.

3.3 바텀업 방식 (DP 테이블)

재귀 호출의 오버헤드를 피하기 위해 아래에서부터 순서대로 계산해 나가는 것이 바텀업 방식입니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def fib_dp(n):
    if n <= 0:
        return 0
    elif n == 1:
        return 1
        
    dp = [0] * (n + 1)
    dp[0] = 0
    dp[1] = 1
    
    for i in range(2, n + 1):
        dp[i] = dp[i-1] + dp[i-2]
        
    return dp[n]

배열 dp 를 준비하고, 인덱스가 작은 쪽부터 순서대로 채워 나갑니다. 이것이 전형적인 DP 테이블의 사용법입니다.

4. 응용편: 배낭 문제

DP의 진면목은 최적화 문제를 풀 때 발휘됩니다. 여기서는 유명한 “0-1 배낭 문제"를 생각해 봅시다.

4.1 문제 설정

당신은 도둑입니다 (라는 설정입니다). 용량이 $W$ 인 배낭을 가지고 있습니다. 눈앞에는 $N$ 개의 물건이 있으며, 각각의 물건 $i$ 에는 무게 $w_i$ 와 가치 $v_i$ 가 설정되어 있습니다.

배낭의 용량을 초과하지 않는 범위 내에서 물건을 골라, 가져갈 물건의 가치 합계를 최대화 해 주십시오. 단, 각 물건은 하나뿐이며, “고른다(1)” 혹은 “고르지 않는다(0)” 중 하나입니다.

4.2 상태의 정의와 점화식

DP로 문제를 풀 때 가장 중요한 것이 상태의 정의 와 점화식(상태 전이 방정식) 의 도출입니다.

상태를 다음과 같이 정의합니다. $dp[i][w]$ : 처음 $i$ 개의 물건 중에서, 무게의 합계가 $w$ 이하가 되도록 골랐을 때의 가치 최댓값.

여기서 $i$ 번째 물건(무게 $w_i$, 가치 $v_i$)을 생각할 때, 다음 2가지 선택지가 있습니다.

고르지 않을 경우: 가치의 최댓값은 이전 상태인 $dp[i-1][w]$ 와 같습니다.
고를 경우 (단, $w \ge w_i$ 인 경우에만 가능): 용량에서 $w_i$ 를 뺀 상태에 물건 $i$ 의 가치 $v_i$ 를 더합니다. 즉, $dp[i-1][w - w_i] + v_i$ 가 됩니다.

따라서 점화식은 다음과 같이 됩니다.

$$ dp[i][w] = \begin{cases} \max(dp[i-1][w], dp[i-1][w - w_i] + v_i) & \text{만약 } w \ge w_i \\ dp[i-1][w] & \text{그 외의 경우} \end{cases} $$

4.3 Python 구현

이 점화식을 그대로 프로그램으로 옮깁니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
def knapsack(weights, values, W):
    N = len(weights)
    # DP 테이블의 초기화: (N+1) x (W+1)의 2차원 배열
    dp = [[0] * (W + 1) for _ in range(N + 1)]
    
    # DP 테이블을 채운다
    for i in range(1, N + 1):
        for w in range(W + 1):
            if w >= weights[i-1]:
                # 고를 경우와 고르지 않을 경우의 최댓값을 취한다
                dp[i][w] = max(dp[i-1][w], dp[i-1][w - weights[i-1]] + values[i-1])
            else:
                # 용량 초과로 고를 수 없는 경우
                dp[i][w] = dp[i-1][w]
                
    return dp[N][W]

DP 테이블의 추이

어느 예에서의 dp 테이블의 추이를 따라가 봅시다.

$i$ \ $w$	1	2	3	4	5
0	0	0	0	0	0
1	0	3	3	3	3
2	2	3	5	5	5
3	2	3	5	6	7
4	2	3	5	6	7

이처럼 작은 용량·적은 물건 수의 부분 문제부터 차례로 최적해를 구해 나감으로써, 최종적으로 답을 얻을 수 있습니다.

5. DP를 더 깊이 이해하기 위한 상세 해설 및 알고리즘 탐구

DP에 대한 이해를 확고히 하기 위해서는 더 많은 예제를 접하고, 다양한 패턴의 상태 전이를 배우는 것이 필수적입니다.

5.1 편집 거리 (레벤슈타인 거리)

두 문자열 $S$ 와 $T$ 가 주어졌을 때, $S$ 에 “삽입”, “삭제”, “치환” 조작을 최소 몇 번 수행해야 $T$ 로 변환할 수 있는지를 구하는 문제입니다.

점화식

$$ dp[i][j] = \begin{cases} dp[i-1][j-1] & \text{만약 } S[i-1] == T[j-1] \\ \min(dp[i][j-1], dp[i-1][j], dp[i-1][j-1]) + 1 & \text{그 외의 경우} \end{cases} $$

5.2 공간 계산량 최적화 기술 (인플레이스 갱신)

지금까지의 구현에서는 상태 전이의 계산에 $O(NW)$ 나 $O(MN)$ 의 메모리를 사용해 왔습니다. 하지만 점화식을 잘 관찰하면, 특정 상태의 갱신에는 “바로 이전 행"만 필요한 경우가 많습니다.

예를 들어 배낭 문제의 점화식을 이용하여 2차원 배열을 1차원 배열로 줄일 수 있습니다. 갱신 시 오른쪽에서 왼쪽으로 갱신함으로써, 현재의 $i$ 를 계산하는 도중에 $i-1$ 의 값을 덮어써 버리는 버그를 방지할 수 있습니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
def knapsack_optimized(weights, values, W):
    N = len(weights)
    dp = [0] * (W + 1)
    
    for i in range(N):
        # 역순으로 갱신함으로써 1차원 배열로 끝난다
        for w in range(W, weights[i] - 1, -1):
            dp[w] = max(dp[w], dp[w - weights[i]] + values[i])
            
    return dp[W]

발전 해설 파트 1: DP의 한계와 알고리즘 선택

동적 계획법의 강점은 부분 구조의 중복을 피하는 것이지만, 그렇다고 해서 모든 문제를 고속으로 풀 수 있는 것은 아닙니다. 예를 들어 배낭 문제의 계산량은 $O(NW)$ 이며, 이는 언뜻 다항식 시간으로 보입니다. 하지만 $W$ 는 입력된 “값"이며, 입력 크기(비트 수)에 대해서는 지수적인 크기가 될 수 있습니다. 이러한 계산량을 의사 다항식 시간 이라고 부릅니다.

만약 $W$ 가 매우 클 경우 배열을 확보하는 것만으로도 메모리가 고갈되고, 루프 횟수도 방대해지기 때문에 이 DP 기법은 적용할 수 없게 됩니다. 그럴 경우에는 가치 총합의 상한 $V$ 에 대한 DP로 전환하거나, 중간에서 만나기(Meet in the Middle)와 같은 다른 접근법이 필요합니다.

또한 DP를 디버깅할 때는 소규모 입력으로 직접 계산한 테이블과 프로그램이 출력하는 테이블을 비교하는 것이 가장 효과적입니다. 종이와 펜을 준비하여 2차원 표를 직접 써봄으로써 “왜 이런 점화식이 되는지”, “어디서 전이를 잘못했는지"를 손에 잡히듯 알 수 있습니다.

발전 해설 파트 2: DP의 한계와 알고리즘 선택

발전 해설 파트 3: DP의 한계와 알고리즘 선택

발전 해설 파트 4: DP의 한계와 알고리즘 선택

발전 해설 파트 5: DP의 한계와 알고리즘 선택

발전 해설 파트 6: DP의 한계와 알고리즘 선택

발전 해설 파트 7: DP의 한계와 알고리즘 선택

발전 해설 파트 8: DP의 한계와 알고리즘 선택

발전 해설 파트 9: DP의 한계와 알고리즘 선택

발전 해설 파트 10: DP의 한계와 알고리즘 선택

발전 해설 파트 11: DP의 한계와 알고리즘 선택

발전 해설 파트 12: DP의 한계와 알고리즘 선택

발전 해설 파트 13: DP의 한계와 알고리즘 선택

발전 해설 파트 14: DP의 한계와 알고리즘 선택

발전 해설 파트 15: DP의 한계와 알고리즘 선택

발전 해설 파트 16: DP의 한계와 알고리즘 선택

발전 해설 파트 17: DP의 한계와 알고리즘 선택

발전 해설 파트 18: DP의 한계와 알고리즘 선택

발전 해설 파트 19: DP의 한계와 알고리즘 선택

발전 해설 파트 20: DP의 한계와 알고리즘 선택

발전 해설 파트 21: DP의 한계와 알고리즘 선택

발전 해설 파트 22: DP의 한계와 알고리즘 선택

발전 해설 파트 23: DP의 한계와 알고리즘 선택

발전 해설 파트 24: DP의 한계와 알고리즘 선택

발전 해설 파트 25: DP의 한계와 알고리즘 선택

발전 해설 파트 26: DP의 한계와 알고리즘 선택

발전 해설 파트 27: DP의 한계와 알고리즘 선택

발전 해설 파트 28: DP의 한계와 알고리즘 선택

발전 해설 파트 29: DP의 한계와 알고리즘 선택

발전 해설 파트 30: DP의 한계와 알고리즘 선택

발전 해설 파트 31: DP의 한계와 알고리즘 선택

발전 해설 파트 32: DP의 한계와 알고리즘 선택

발전 해설 파트 33: DP의 한계와 알고리즘 선택

발전 해설 파트 34: DP의 한계와 알고리즘 선택

발전 해설 파트 35: DP의 한계와 알고리즘 선택

발전 해설 파트 36: DP의 한계와 알고리즘 선택

발전 해설 파트 37: DP의 한계와 알고리즘 선택

발전 해설 파트 38: DP의 한계와 알고리즘 선택

발전 해설 파트 39: DP의 한계와 알고리즘 선택

발전 해설 파트 40: DP의 한계와 알고리즘 선택

6. 맺음말

동적 계획법(DP)은 처음에는 다가가기 어렵게 느껴질지도 모릅니다. 하지만 피보나치 수열에서의 “불필요한 계산 배제"라는 직관적인 이해에서 출발하여, 배낭 문제와 같은 “상태와 전이의 정의"로 단계를 밟아 나감으로써 반드시 마스터할 수 있습니다.

“상태를 어떻게 정의할 것인가” “그 상태는 어떤 작은 상태로부터 계산할 수 있는가 (점화식)”

이 2가지를 꿰뚫어 보는 힘을 기르기 위해서는 많은 문제를 접하고, 내 손으로 직접 DP 테이블을 작성해 보는 것이 가장 빠른 길입니다. 부디 본 기사에서 배운 지식을 무기로 도전해 보시기 바랍니다.