이코테 강의 몰아보기 | 6. 다이나믹 프로그래밍

 

[1] 다이나믹 프로그래밍

: 메모리를 적절히 사용하여 수행 시간 효율성을 비약적으로 향상시키는 방법이다.

이미 계산된 결과(작은 문제)는 별도의 메모리 영역에 저장하여 다시 계산하지 않도록 한다. 다이나믹  프로그래밍의 구현은 일반적으로 두 가지 방식(탑다운과 보텀업)으로 구성된다.

 

1. 피보나치 수열

: 피보나치 수열은 다이나믹 프로그래밍으로 효과적으로 계산할 수 있다.

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

 

 

2. 메모이제이션(Memoization)

: 다이나믹 프로그래밍을 구현하는 방법 중 하나로 한 번 계산한 결과를 메모리 공간에 메모하는 기법이다.

- 같은 문제를 다시 호출하면 메모했던 결과를 그대로 가져온다.

- 값을 기록해 놓는다는 점에서 캐싱(Caching)이라고도 한다.

 

3. 탑다운(하향식) vs 보텀업(상향식)

- 탑다운(메모이제이션) 방식은 하향식이라고도 하며 보텀업 방식은 상향식이라고도 한다.

- 다이나믹 프로그래밍의 전형적인 형태는 보텀업 방식이다. 결과 저장용 리스트는 DP 테이블이라고 부른다.

- 메모이제이션은 이전에 계산된 결과를 일시적으로 기록해 놓는 넓은 개념을 의미한다.

 

3-1. 탑다운 다이나믹 프로그래밍(피보나치)

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

# 피보나치 함수를 재귀함수로 구현(탑 다운 다이나믹 프로그래밍)
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))

 

3-2. 보텀업 다이나믹  프로그래밍(피보나치)

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

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

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

print(d[n])

 

4. 실전 문제

#page220. 개미전사

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

# 정수 N을 입력받기
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])

 

 

#page217. 1로 만들기

아이디어 : 문제에서 요구하는 내용을 점화식으로 표현해보자. 점화식 끝에 1을 더해주는 이유는 함수의 호출 횟수를 구해야 하기 때문이다.

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

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

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

 

#page226. 효율적인 화폐 구성

아이디어 : 점화식(각 화폐 단위인 k를 하나씩 확인)

# 정수 N,M을 입력받기
n, m =map(int,input().split())
# N개의 화폐 단위 정보를 입력받기
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 : #(j-k)원을 만드는 방법이 존재하는 경우
            d[j] = min(d[j], d[j- array[i]] + 1)

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

 

#page375. 금광

아이디어 : 금광의 모든 위치에 대하여 다음의 세 가지만 고려한다.

- 왼쪽 위에서 오는 경우

- 왼쪽 아래에서 오는 경우

- 왼쪽에서 오는 경우

세 가지의 경우 중에서 가장 많은 금을 가지고 있는 경우를 테이블에 갱신해주어 문제를 해결한다.

#테스트 케이스 입력
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):
        dp.append(array[index:index + m])
        index += m
    # 다이나믹 프로그래밍 진행
    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)

 

#380. 병사 배치하기

아이디어 : 가장 긴 증가하는 부분 수열(LIS)로 알려진 전형적인 다이나믹 프로그래밍 문제의 아이디어와 같다.

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