DP(다이나믹 프로그래밍)

PANGHYUK·2022년 1월 28일
0

알고리즘 스터디

목록 보기
8/13
post-thumbnail

DP(다이나믹 프로그래밍)이란?

  • 다이나믹 프로그래밍(DP)은 메모리를 적절히 사용하여 수행 시간 효율성을 비약적으로 향상시키는 방법
  • 이미 계산된 결과(작은 문제)는 별도의 메모리 영역에 저장하여 다시 계산 X
  • 다이나믹 프로그래밍의 구현은 일반적으로 두가지 방식(탑 다운/보텀 업)으로 구성
  • 자료구조에서 동적 할당(Dynamic Allocation)은 '프로그램이 실행되는 도중에 실행에 필요한 메모리를 할당하는 기법'을 의미
  • 반면 DP에서 '다이나믹'은 별다른 의미 없이 사용된 단어

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

1. 최적 부분 구조(Optimal Substructure)

  • 큰 문제를 작은 문제로 나눌 수 있으며 작은 문제의 답을 모아서 큰 문제를 해결할 수 있음

2. 중복되는 문제(Overlapping Subproblem)

  • 동일한 작은 문제를 반복적으로 해결해야 함

피보나치 수열

단순 재귀 소스코드

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

print(fibo(4))

시간 복잡도

DP가 필요한 이유: 효율적인 방법

메모이제이션(Memoization)이란?

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

Top-Down VS Bottom-Up

  • Top-Down(메모이제이션) 방식은 하향식이라고도 하며 Bottom-Up 방식은 상향식이라고도 함
  • DP의 전형적인 형태는 Bottom-Up
    -결과 저장용 리스트는 DP 테이블이라고 부름
  • 메모이제이션은 이전에 계산된 결과를 일시적으로 기록해 놓는 넓은 개념을 의미
    -따라서 메모이제이션은 DP에 국한된 개념 X
    -한 번 계산된 결과를 담아 놓기만 하고 DP를 위해 활용하지 않을 수도 있음

Top-Down방식 소스코드

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

# 피보나치 함수를 재귀로 구현(Top-Down)
def fibo(x):
    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))

Bottom-Up방식 소스코드

d = [0] * 100

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

# 피보나치 함수 반복문으로 구현(Bottom-Up)
for i in range(3,n+1):
    d[i] = d[i-1] + d[i-2]

print(d[n])

메모이제이션 동작 분석 소스코드

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

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)
    return d[x]

fibo(6)

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

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

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

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

문제 1: 개미 전사

문제 풀이

n = int(input())
arr = list(map(int,input().split()))

d = [0] * 100

d[0] = arr[0]
d[1] = max(arr[0],arr[1])

for i in range(2,n):
    d[i] = max(d[i-1],d[i-2] + arr[i])

print(d[n-1])

문제 2: 1로 만들기

문제 풀이

x = int(input())

d = [0] * 30001

for i in range(2,x+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])

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

문제 풀이

n,m = map(int,input().split())
arr = []

for i in range(n):
    arr.append(int(input()))

d = [10001] * (m + 1)

d[0] = 0
for i in range(n):
    for j in range(arr[i],m+1):
        if d[j - arr[i]] != 10001: # (i-k)원을 만드는 방법이 존재하는 경우
            d[j] = min(d[j],d[j - arr[i]] + 1)

if d[m] == 10001: # 최종적으로 m원을 만드는 방법이 없는 경우
    print(-1)
else:
    print(d[m])

문제 4: 금광

문제 풀이

for tc in range(int(input())):
    n,m = map(int,input().split())
    arr = list(map(int,input().split()))

    dp = []
    idx = 0
    for _ in range(n):
        dp.append(arr[idx:idx+m])
        idx += 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)
    
    res = 0

    for i in range(n):
        res = max(res,dp[i][m-1])
    
    print(res)

문제 5: 병사 배치하기

문제 풀이

n = int(input())
arr = list(map(int,input().split()))
arr.reverse()

dp = [1] * n

for i in range(1,n):
    for j in range(0,i):
        if arr[j] < arr[i]:
            dp[i] = max(dp[i],dp[j] + 1)

print(n-max(dp))

0개의 댓글