6. 다이나믹 프로그래밍

1. 다이나믹 프로그래밍을 사용할 수 있는 경우

: 다음 조건을 만족할 때 사용할 수 있다

• 큰 문제를 작은 문제로 나눌 수 있다.
• 작은 문제에서 구한 정답은 그것을 포함하는 큰 문제에서도 동일하다

 

2. 메모이제이션 (Memoization) 기법

- 다이나믹 프로그래밍을 구현하는 방법 중 한 종류이다.

- 한 번 구한 결과를 메모리 공간에 메모해두고 같은 식을 다시 호출하면 메모한 결과를 그대로 가져오는 기법

- 캐싱(Caching)이라고도 한다.

 

- 메모이제이션으로 구현한 피보나치 수열

d = [0] * 100

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]

 

3. 탑다운 & 보텀업 방식

- 탑다운 (Top-Down) 방식 : 재귀 함수를 이용하여 큰 문제를 해결하기 위해 작은 문제를 호출

=> 메모이제이션은 탑다운 방식에 속한다

=> '하향식' 이라고도 함

- 보텀업 (Botton-Up) 방식 : 반복문을 이용하여 작은 문제부터 차근차근 답을 도출

=> 다이나믹 프로그래밍의 전형적인 형태이다

=> '상향식'이라고도 함

 

* DP 테이블 : 보텀업 방식에서 사용되는 결과 저장용 리스트

 

- 보텀업 방식으로 구현한 피보나치 수열

d = [0] * 100

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

 

<문제>

1. 1로 만들기

- 정수 X가 주어질때 정수 X에 사용할 수 있는 연산은 다음과 같이 4가지이다.

1. X가 5로 나누어떨어지면, 5로 나눈다.
2. X가 3으로 나누어 떨어지면, 3으로 나눈다.
3. X가 2로 나누어 떨어지면, 2로 나눈다.
4. X에서 1을 뺀다.

정수 X가 주어졌을때, 연산 4개를 적절히 사용해서 1을 만들려고 한다. 연산을 사용하는 횟수의 최솟값을 출력하시오.

 

예를 들어 정수가 26이면 다음과 같이 계산해서 3번의 연산이 최솟값이다.

1. 26 - 1 = 25 (ⓓ)
2. 25 /5 = 5 (ⓐ)
3. 5 / 5 = 1 (ⓐ)

 

<입력 조건>

• 첫째 줄에 정수 X가 주어진다 (1 <= X <= 30,000)

<출력 조건>

• 첫째 줄에 연산을 하는 횟수의 최솟값을 출력한다.

입력 예시 26

출력 예시 3

 

import sys

n = int(sys.stdin.readline().rstrip())

dp_table = [0] *(n+1)

dp_table[n] = 1

for i in range(n,1,-1):
    if dp_table[i] != 0:
        if i%5 == 0:
            if dp_table[i//5] ==0 or dp_table[i//5] > dp_table[i]+1:
                dp_table[i//5] = dp_table[i] + 1

        if i%3 == 0:
            if dp_table[i//3] ==0 or dp_table[i//3] > dp_table[i]+1:
                dp_table[i//3] = dp_table[i] + 1

        if i%2 == 0:
            if dp_table[i//2] ==0 or dp_table[i//2] > dp_table[i]+1:
                dp_table[i//2] = dp_table[i] + 1

        if dp_table[i-1] ==0 or dp_table[i-1] > dp_table[i]+1:
            dp_table[i-1] = dp_table[i]+1

print(dp_table[1]-1)

 

2. 개미 전사

- 개미 전사는 부족한 식량을 충당하고자 메뚜기 마을의 식량창고를 몰래 공격하려고 한다.
메뚜기 마을에는 여러 개의 식량창고가 있는데 식량창고는 일직선으로 이어져 있다.
각 식량창고에는 정해진 수의 식량을 저장하고 있으며 개미 전사는 식량창고를 선택적으로 약탈하여 식량을 빼앗을 예정이다.
이때 메뚜기 정찰병들은 일직선상에 존재하는 식량창고 중에서 서로 인접한 식량창고가 공격받으면 바로 알아챌 수 있다.
따라서 개미 전사가 정찰병에게 들키지 않고 식량창고를 약탈하기 위해서는 최소한 한 칸 이상 떨어진 식량창고를 약탈해야 한다.
예를 들어 식량창고 4개가 다음과 같이 존재한다고 가정하자.

 

{1, 3, 1, 5}

 

이때 개미 전사는 두 번째, 네 번째 식량창고를 선택했을 때 최댓값인 총 8개의 식량을 빼앗을 수 있다.
개미 전사는 식량창고가 이렇게 일직선상일 때 최대한 많은 식량을 얻기를 원한다.
개미 전사를 위해 식량창고 N개에 대한 정보가 주어졌을 때 얻을 수 있는 식량의 최댓값을 구하는 프로그램을 작성하시오.

<입력 조건>

• 첫째 줄에 식량창고의 개수 N이 주어진다. (3 <= N < =100)
• 둘째 줄에 공백으로 구분되어 각 식량창고에 저장된 식량의 개수 K가 주어진다. (0 <= K <= 1,000)

<출력 조건>

• 첫째 줄에 개미 전사가 얻을 수 있는 식량의 최댓값을 출력하시오

입력 예시 4 1 3 1 5

출력 예시 8

import sys

n = int(sys.stdin.readline().rstrip())

foods = list(map(int, sys.stdin.readline().rstrip().split()))

dp_table = [0] * n

dp_table[0] = foods[0]
dp_table[1] = foods[1]

for i in range(n):
    n1 = i+2
    n2 = i+3

    if n1<n:
        dp_table[n1] = dp_table[i] + foods[n1]

    if n2<n:
        dp_table[n2] = dp_table[i] + foods[n2]

print(max(dp_table[n-2],dp_table[n-1]))

 

3. 바닥 공사

- 가로의 길이가 N, 세로의 길이가 2인 직사각형 형태의 얇은 바닥이 있다. 태일이는 이 얇은 바닥을 1 x 2의 덮개, 2 x 1 의 덮개, 2 x 2의 덮개를 이용해 채우고자 한다.

 

이때, 바닥을 채우는 모든 경우의 수를 구하는 프로그램을 작성하시오. 예를 들어 2 x 3 크기의 바닥을 채우는 겨우의 수는 5가지이다.

 

<입력 조건>

• 첫째 줄에 N이 주어진다. (1 <= N <= 1,000)

<출력 조건>

• 첫째 줄이 2 x N 크기의 바닥을 채우는 방법의 수를 796,796으로 나눈 나머지를 출력한다.

입력 예시 3

출력 예시 5

import sys

n = int(sys.stdin.readline().rstrip())

dp_table = [0] * (n+1)
dp_table[0] = 1

for i in range(n):
    if i+2 <= n:
        dp_table[i+2] += dp_table[i] * 2

    if i+1 <= n:
        dp_table[i+1] += dp_table[i]

print(dp_table[n]%796796)

 

4. 효율적인 화폐 구성

- N가지 종류의 화폐가 있다. 이 화폐들의 개수를 최소한으로 이용해서 그 가치의 합이 M원이 되도록 하려고 한다. 이 때, 각 화폐는 몇 개라도 사용할 수 있으며, 사용한 화폐의 구성은 같지만 순서만 다른 것은 같은 경우로 구분한다. 예를 들어 2원, 3원 단위의 화폐가 있을 때는 15원을 만들기 위해 3원을 5개 사용하는 것이 가장 최소한의 화폐 개수이다.

 

<입력 조건>

• 첫째 줄에 N,M이 주어진다. (1 <= N <=100, 1 <= M <=10,000)
• 이후의 N개의 줄에는 각 화폐의 가치가 주어진다. 화폐의 가치는 10,000 보다 작거나 같은 자연수이다.

<출력 조건>

• 첫째 줄에 경우의 수 X를 출력한다.
• 불가능할 때는 -1을 출력한다.

입력 예시 1 2 15 2 3

출력 예시 1 5

입력 예시 2 3 4 3 5 7

출력 예시 2 -1

import sys

n,m = map(int, sys.stdin.readline().rstrip().split())

dp_table = [0] * (10001)

cashes = []

for _ in range(n):
    n_cashes = int(sys.stdin.readline().rstrip())
    cashes.append(n_cashes)
    dp_table[n_cashes] = 1

for i in range(m):
    if dp_table[i] != 0:
        for c in cashes:
            if i+c <= m:
                if dp_table[i+c] != 0:
                    dp_table[i+c] = min(dp_table[i] + 1,dp_table[i+c])
                else:
                    dp_table[i+c] = dp_table[i]+1

if dp_table[m] == 0:
    print(-1)
else:
    print(dp_table[m])

 

5. 금광

- n x m 크기의 금광이 있습니다. 금광은 1 x 1 크기의 칸으로 나누어져 있으며, 각 칸은 특정한 크기의 금이 들어있습니다. 채굴자는 첫 번째 열부터 출발하여 금을 캐기 시작합니다. 맨 처음에는 첫 번째 열의 어느 행에서든 출발할 수 있습니다. 이후에 m번에 걸쳐서 매번 오른쪽 위, 오른쪽, 오른쪽 아래 3가지 중 하나의 위치로 이동해야 합니다. 결과적으로 채굴자가 얻을 수 있는 금의 최대 크기를 출력하는 프로그램을 작성하세요.

만약 다음과 같이 3 x 4 크기의 금광이 존재한다고 가정합시다.

1	3	3	2
2	1	4	1
0	6	4	7

가장 왼쪽 위의 위치를 (1,1), 가장 오른쪽 아래의 위치를 (n,m)이라고 할 때, 위 예시에서는 (2,1) -> (3,2) -> (3,3) -> (3,4)의 위치로 이동하면 총 19만큼의 금을 채굴할 수 있으며, 이 때의 값이 최댓값입니다.

 

<입력 조건>

• 첫째 줄에 테스트 케이스 T가 입력됩니다. (1 <= T <= 1000)
• 매 테스트 케이스 첫째 줄에 n과 m이 공백으로 구분되어 입력됩니다. (1 <= n,m <=20)
• 둘째 줄에 n x m개의 위치에 매장된 금의 개수가 공백으로 구분되어 입력됩니다. (1<= 각 위치에 매장된 금의 개수 <= 100)

<출력 조건>

• 테스트 케이스마다 채굴자가 얻을 수 있는 금의 최대 크기를 출력합니다. 각 테스트 케이스는 줄 바꿈을 이용해 구분합니다

입력 예시 2 3 4 1 3 3 2 2 1 4 1 0 6 4 7 4 4 1 3 1 5 2 2 4 1 5 0 2 3 0 6 1 2

출력 예시 19 16

import sys

t = int(sys.stdin.readline().rstrip())

moves = [(-1,-1),(0,-1),(1,-1)] #y,x

for _ in range(t):
    n,m = map(int,sys.stdin.readline().rstrip().split())
    inputs = list(map(int,sys.stdin.readline().rstrip().split()))
    golds = []
    dp_tables = []
    maximum = 0

    for i in range(n):
        golds.append(inputs[i*m:(i+1)*m])
        dp_tables.append(inputs[i*m:(i+1)*m])
        

    for x in range(m):
        for y in range(n):
            for my, mx in moves:
                dy = my + y
                dx = mx + x

                if dy < 0 or dy>=n or dx<0 or dx>=m:
                    continue

                dp_tables[y][x] = max(dp_tables[y][x], dp_tables[dy][dx]+golds[y][x])

                if maximum < dp_tables[y][x]:
                    maximum = dp_tables[y][x]
    
    print(maximum)

 

6. 정수 삼각형

https://www.acmicpc.net/problem/1932

1932번: 정수 삼각형

import sys

n = int(sys.stdin.readline().rstrip())

triangles = []

for _ in range(n):
    triangles.append(list(map(int,sys.stdin.readline().rstrip().split())))

for y in range(n-2,-1,-1):
    for x in range(y+1):
        triangles[y][x] += max(triangles[y+1][x], triangles[y+1][x+1])

print(triangles[0][0])

 

7. 퇴사

https://www.acmicpc.net/problem/14501

14501번: 퇴사

import sys

n = int(sys.stdin.readline().rstrip())

t_arr=[]
p_arr=[]
dp_tables = [0] * (n+1)

for _ in range(n):
    ti, pi = map(int,sys.stdin.readline().rstrip().split())
    t_arr.append(ti)
    p_arr.append(pi)

for i in range(n):
    dp_tables[i] = max(dp_tables[i],dp_tables[i-1])
    
    if t_arr[i]+i <= n:
        dp_tables[t_arr[i]+i] = max(dp_tables[t_arr[i]+i], p_arr[i]+dp_tables[i])

dp_tables[n] = max(dp_tables[n], dp_tables[n-1])

print(dp_tables[n])

 

8. 병사 배치하기

https://www.acmicpc.net/problem/18353

18353번: 병사 배치하기

import sys

n = int(sys.stdin.readline().rstrip())

numbers = list(map(int,sys.stdin.readline().rstrip().split()))
dp_tables = [0] *(n)
numbers.reverse()

for i in range(n):
    for j in range(i-1,-1,-1):
        if numbers[j] < numbers[i]:
            dp_tables[i] = max(dp_tables[j]+1, dp_tables[i])

    if dp_tables[i] == 0:
        dp_tables[i] = 1

print(n-max(dp_tables))

 

9. 못생긴 수

- 못생긴 수란 오직 2,3,5만을 소인수로 가지는 수를 의미합니다. 다시 말해 오직 2,3,5를 약수로 가지는 합성수를 의미합니다. 1은 못생긴수라고 가정합니다. 따라서 못생긴 수들은 {1,2,3,4,5,6,8,9,10,12,15...} 순으로 이어지게 됩니다. 이 때, n번째 못생긴 수를 찾는 프로그램을 작성하세요. 예를들어 11번째 못생긴 수는 15입니다.

 

<입력 조건>

• 첫째 줄에 n이 입력됩니다. (1 <= n <= 1,000)

<출력 조건>

• n번째 못생긴 수를 출력합니다.

입력 예시 1 10

출력 예시 1 12

입력 예시 2 4

출력 예시 2 4

import sys

n = int(sys.stdin.readline().rstrip())

ugly = [0] * n
ugly[0] = 1

i2 = i3 = i5 = 0
next2,next3,next5 = 2,3,5

for l in range(1,n):
    ugly[l] = min(next2, next3, next5)

    if ugly[l] == next2:
        i2 += 1
        next2= ugly[i2] * 2

    if ugly[l] == next3:
        i3 += 1
        next3= ugly[i3] * 3

    if ugly[l] == next5:
        i5 += 1
        next5= ugly[i5] * 2

print(ugly)

 

10. 편집 거리

- 두 개의 문자열 A와 B가 주어졌을 때, 문자열 A를 편집하여 문자열 B로 만들고자 합니다. 문자열 A를 편집할 때는 다음의 세 연산 중에서 한 번에 하나씩 선택하여 이용할 수 있습니다.

1. 삽입 (Insert) : 특정한 위치에 하나의 문자를 삽입합니다.
2. 삭제 (Remove) : 특정한 위치에 있는 하나의 문자를 삭제합니다.
3. 교체 (Replace) : 특정한 위치에 있는 하나의 문자를 다른 문자로 교체합니다.

이 때 편집 거리란 문자열 A를 편집하여 문자열 B로 만들기 위해 사용한 연산의 수를 의미합니다. 문자열 A를 문자열 B로 만드는 최소 편집 거리를 계산하는 프로그램을 작성하세요. 예를 들어 "sunday"와 "saturday"의 최소 편집 거리는 3입니다.

 

<입력 조건>

• 두 문자열 A와 B가 한 줄에 하나씩 주어집니다.
• 각 문자열은 영문 알파벳으로만 구성되어 있으며, 각 문자열의 길이는 1보다 크거나 같고, 5,000 보다 작거나 같습니다.

<출력 조건>

• 최소 편집 거리를 출력합니다.

입력 예시 1 cat cut

출력 예시 1 1

입력 예시 2 sundau saturday

출력 예시 2 3

* 풀이
행과 열에 해당하는 문자를 비교 후, 문자가 서로 같다면, 왼쪽 위에 해당하는 수를 그대로 대입

다르다면, 왼쪽(삽입), 위쪽(삭제), 왼쪽 위(교체)에 해당하는 수 중에서 가장 작은 수에 1을 더해 대입

import sys

strA = sys.stdin.readline().rstrip()
strB = sys.stdin.readline().rstrip()

n = len(strA)
m = len(strB)

dp = [[0]*(m+1) for _ in range(n+1)]

for i in range(1,n+1):
    dp[i][0] = i

for j in range(1,m+1):
    dp[0][j] = j

for i in range(1,n+1):
    for j in range(1,m+1):
        if strA[i-1] == strB[j-1]:
            dp[i][j] = dp[i-1][j-1]
        else:
            dp[i][j] = min(dp[i-1][j-1],dp[i-1][j],dp[i][j-1])+1

print(dp[n][m])