Algorithm/algorithm_study

다이나믹 프로그래밍(Dynamic Programming)

민철킹 2021. 3. 18. 20:48

다이나믹 프로그래밍🤩

  • 다이나믹 프로그래밍은 메모리를 적절히 사용하여 수행 시간 효율성을 비약적으로 향상시키는 방법
  • 이미 계산된 결과(작은 문제)는 별도의 메모리 영역에 저장하여 다시 계산하지 않도록 합니다.
    • 중복 계산을 하지 않는다는 의미
  • 다이나믹 프로그래밍의 구현은 일반적으로 두 가지 방식
    • 탑 다운(Top Down) - 위에서 아래로(하향식)
    • 바텀 업(Bottom Up) - 아래에서 위로(상향식)
  • 동적 계획법이라고도 부름
  • 일반적인 프로그래밍 분야에서의 동적(Dynamic)이란 어떤 의미를 가질까?
    • 자료구조에서 동적 할당(Dynamic Allocation)은 "프로그램이 실행되는 도중에 실행에 필요한 메모리를 할당하는 기법"을 의미
    • 반면 다이나믹 프로그래밍에서는 별다른 의미 없이 사용된 단어.

 

 

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

  • 최적 부분 구조(Optimal Substructure)
    • 큰 문제를 작은 문제로 나눌 수 있으며 작은 문제의 답을 모아서 큰 문제를 해결
  • 중복되는 부분 문제(Overlapping Subproblem)
    • 동일한 작은 문제를 반복적으로 해결해야 한다.

 

 

 

피보나치 수열

  • 피보나치 수열은 다음과 같은 형태의 수열이며, 다이나믹 프로그래밍으로 효과적으로 계산할 수 있음.
    • 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ......
  • 점화식이란 인접한 항들 사이의 관계식을 의미합니다.
  • 피보나치 수열을 점화식을 표현하면 다음과 같습니다.

  • 피보나치 수열이 계산되는 과정은 다음과 같이 표현할 수 있다.
    • 프로그래밍에서는 이러한 수열을 배열이나 리스트를 이용해 표현

 

  • 피보나치 수열이 계산되는 과정은 다음과 같이 표현할 수 있습니다.
    • n번째 피보나치 수를 F(n)라고 할 때 4번째 피보나치 수 F(4)를 구하는 과정은 다음과 같다.

 

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

  • 단순 재귀 함수로 피보나치 수열을 해결하면 지수 시간 복잡도를 가지게 된다.
  • 다음과 같이 f(2)가 여러번 호출되는 것을 확인할 수 있음.(중복 계산 문제)

 

 

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

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

 

 

메모이제이션(Memoization)

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

 

 

탑다운 vs 바텀업

  • 탑다운(메모이제이션) 방식은 하향식이라고도 하며, 바텀업 방식은 상향식이라고도 함
  • DP의 전형적인 형태는 바텀업 방식
    • 결과 저장용 리스트는 DP 테이블이라고 부름
  • 엄밀히 말하면 메모이제이션은 이전에 계산된 결과를 일시적으로 기록해 놓는 넓은 개념을 의미
    • 따라서 메모이제이션은 DP에 국한된 개념은 아님
    • 한 번 계산된 결과를 담아 놓기만 하고 DP를 위해 활용하지 않을 수도 있음.

 

피보나치 수열 : 탑다운 DP 소스코드

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

# 피보나치 함수를 재귀함수로 구현(탑다운 DP)
def fibo(x):
    # 종료 조건(1 or 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))

 

피보나치 수열 : 바텀업 DP 소스코드

# 앞서 계산된 결과를 저장하기 위한 DP 테이블 초기화
d = [0] * 100
# f(1) 과 f(2)는 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])

 

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


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

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

 

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

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

 

 

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

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

 


 

<문제> 개미 전사 : 문제 설명

 

<문제> 개미 전사 : 문제 조건

 

나의 문제 풀이(소스 코드)

n = int(input())
k = list(map(int, input().split()))
dp = [0 for _ in range(n + 1)]
dp[1] = k[0]
dp[2] = max(k[0], k[1])
for i in range(3, n + 1):
    dp[i] = max(dp[i-1], k[i-1]+ dp[i-2])
print(dp[-1])

 

문제 해결 아이디어

내가 세운 점화식과 일치 !~! 🙃🙃

 

답안 예시


 

<문제> 1로 만들기

*문제 설명

 

문제 조건

 

나의 풀이

x = int(input())
dp = [0 for _ in range(x+1)]
for i in range(2, x+1):
    dp[i] = dp[i-1] + 1

    if i % 2 == 0 and dp[i] > dp[i//2] +1:
        dp[i] = dp[i//2] + 1
    if i % 3 == 0 and dp[i] > dp[i//3] +1:
        dp[i] = dp[i//3] + 1
    if i % 5 == 0 and dp[i] > dp[i//5] +1:
        dp[i] = dp[i//5] + 1
print(dp[x])

 

 

 

문제 해결 아이디어

 

답안 예시

x = int(input())
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)
    if i % 3 == 0:
        d[i] = min(d[i], d[i // 3] + 1)
    if i % 5 == 0:
        d[i] = min(d[i], d[i // 5] + 1)
print(d[x])

<문제> 효율적인 화폐 구성

 

문제 조건

 

문제 해결 아이디어

 

답안 예시

n, m = map(int, input().split())
bills = [int(input()) for _ in range(n)]
dp = [10001 for _ in range(m+1)]
dp[0] = 0
for i in bills:
    for j in range(i, m+1):
        if dp[j - i] != 10001:
            dp[j] = min(dp[j], dp[j - i] + 1)
if dp[m] == 10001:
    print(-1)
else:
    print(dp[m])

<문제> 금광

 

문제 조건

 

문제 해결 아이디어

 

나의 풀이

t = int(input())
for _ in range(t):
    n, m = map(int, input().split())
    golds = list(map(int, input().split()))
    graph = []
    temp = 0
    for i in range(n):
        graph.append(golds[temp: temp + m])
        temp += m
    for i in range(1, m):
        for j in range(n):
            if j-1 < 0:
                graph[j][i] += max(graph[j][i-1], graph[j+1][i-1])
            elif j+1 == n:
                graph[j][i] += max(graph[j-1][i-1], graph[j][i-1])
            else:
                graph[j][i] += max(graph[j-1][i-1], graph[j][i-1], graph[j+1][i-1])
    answer = 0
    for i in range(n):
        answer = max(answer, graph[i][m-1])
    print(answer)

 

 

답안 예시

t = int(input())
for _ in range(t):
    n, m = map(int, input().split())
    array = list(map(int, input().split()))
    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)
    answer = 0
    for i in range(n):
        answer = max(answer, dp[i][m-1])
    print(answer)

<문제> 병사 배치하기

 

문제 조건

 

나의 풀이

n = int(input())
soldiers = list(map(int, input().split()))
answer = 0
for i in range(n-1):
    if soldiers[i] < soldiers[i+1]:
        answer += 1
print(answer)

 

 

문제 해결 아이디어

답안 예시

n = int(input())
array = list(map(int, input().split()))
array.reverse()
dp = [1] * n
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))

 

 

더보기

출처 : 유튜브 [동빈나]님의 "이것이 코딩 테스트다" 강의를 보고 공부했습니다.

 

 

 

 

반응형

'Algorithm > algorithm_study' 카테고리의 다른 글

기타 그래프 이론  (0) 2021.04.19
최단 경로 알고리즘(Shortest Path)  (0) 2021.03.30
이진 탐색  (0) 2021.02.14
DFS & BFS  (0) 2021.01.31
구현 : 시뮬레이션과 완전 탐색  (0) 2021.01.27