[TIL] 다이나믹 프로그래밍 (동적 계획법, DP) / 이코테 - 개미 전사, 1로 만들기, 효율적인 화폐 구성

[주절주절]

자기소개서 써야해서 + 엄마, 아빠가 싱가포르 놀러오셔서 멈춰버린 알고리즘 공부..
다행히 지난주 금요일에 있었던 코테는 무난무난하게 치렀다. 

그래도 알고리즘 공부는 계속해볼 예정. 앞으로 뭐하고 살지~

 

[Today I Learned]

# 다이나믹 프로그래밍

- 메모리를 적절히 사용하여 수행 시간 효율성을 향상시키는 방법
- 이미 계산된 결과(작은 문제)는 별도의 메모리 영역에 저장해 다시 계산하지 않도록
- 일반적으로 탑다운, 보텀업, 두 가지 방식으로 구성

- 동적 계획법이라고도 부르나 별 다른 의미 X

- 다이나믹 프로그래밍은 문제가 다음의 조건을 만족할 때 사용 가능
ㄴ 1. 최적 부분 구조 : 큰 문제를 작은 문제로 나눌 수 있으며 작은 문제의 답을 모아 큰 문제를 해결할 수 있을 때
ㄴ 2. 중복되는 부분 문제 : 동일한 작은 문제를 반복적으로 해결해야 할 때

eg. 피보나치 수열

단순 재귀 함수로 피보나치 수열을 해결하면 지수 시간 복잡도를 갖게됨. (중복 호출되는 연산 발생)
따라서 DP를 통해 시간 복잡도를 줄일 수 있다.

 

# 메모이제이션(Memoization) ; 탑다운 방식

- 한 번 계산한 결과를 메모리 공간에 메모하는 기법
- 별도의 배열(리스트)에 값을 기록해 놓는다는 점에서 캐싱(Caching)이라고도 함

- 주의! 이전에 계산된 결과를 일시적으로 기록해 놓는 넓은 개념 의미. DP에 국한된 개념 X

+ 탑다운 vs. 보텀업
- 전형적인 형태는 보텀업(상향식). DP 테이블(Python 기준 리스트)에 결과 저장.
- 이전에 계산된 결과를 일시적으로 기록해 놓는 넓은 개념

피보나치 수열 문제

# 탑 다운
# Memoization > 리스트 초기화
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]

# 보텀 업
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])

 

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

- 두 방법 모두 최적 부분 구조를 가질 때 사용할 수 있음
- 차이는 부분 문제의 중복. 다이나믹 프로그래밍 문제에서는 각 부분 문제들이 서로 영향을 미치며 중복되지만, 분할 정복 문제에서는 동일한 부분 문제가 반복적으로 계산되지 않음.

- 따라서, 주어진 문제가 DP 유형임을 파악하는 것이 중요
- 다른 알고리즘으로 풀이 방법이 떠오르지 않을 때 고려해보자.

# 이코테 - 개미 전사

문제

개미전사는 부족한 식량을 충당하고자 메뚜기 마을의 식량창고를 몰래 공격하려고 한다. 메뚜기 마을에는 여러 개의 식량창고가 있는데 식량창고는 일직선으로 이어져 있다. 각 식량창고에는 정해진 수의 식량을 저장하고 있으며 개미 전사는 식량창고를 선택적으로 약탈하여 식량을 빼앗을 예정이다. 이때 메뚜기 정찰병들은 일직선상에 존재하는 식량창고 중에서 서로 인접한 식량창고가 공격받으면 바로 알아챌 수 있다. 따라서 개미 전사가 정찰병에게 들키지 않고 식량창고를 약탈하기 위해서는 최소한 한 칸 이상 떨어진 식량창고를 약탈해야 한다. 예를 들어 식량창고 4개가 다음과 같이 존재한다고 가정하자.
{1, 3, 1, 5}이때 개미 전사는 두 번째 식량창고와 네 번째 식량창고를 선택했을 때 최댓값인 총 8개의 식량을 빼앗을 수 있다. 개미 전사는 식량창고가 이렇게 일직선상일 때 최대한 많은 식량을 얻기를 원한다.
개미 전사를 위해 식량창고 N개에 대한 정보가 주어졌을 때 얻을 수 있는 식량의 최댓값을 구하는 프로그램을 작성하시오.

 

@solution.py

a_i를 i번째 식량 창고까지의 최적의 해로 두고 풀기.

 

# Bottom - up
n = int(input())
foods = list(map(int, input().split()))

d = [0] * 100

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

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

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을 만들어야한다. 이 연산을 사용하는 횟수의 최솟값을 출력해라.

X = 26일 경우
1. 26 - 1 = 25
2. 25 / 5 = 5
3. 5 / 5 = 1

 

@solution.py

from collections import deque

n = int(input())

dp = [0] * n # 숫자를 바로 인덱스로 사용

queue = deque([(n,1)])

while queue:
    
    i,c = queue.popleft()

    if i % 5 == 0 and dp[i//5] == 0:
        dp[i//5] = c
        queue.append((i//5,c+1))

    elif i % 3 == 0 and dp[i//3] == 0:
        dp[i//3] = c
        queue.append((i//3,c+1))

    elif i % 2 == 0 and dp[i//2] == 0:
        dp[i//2] = c
        queue.append((i//2,c+1))

    if dp[i-1] == 0:
        dp[i-1] = c
        queue.append((i-1,c+1))

    if dp[1] != 0:
        break

print(dp[1])

이것이 다이나믹 프로그래밍이 맞는지요...? 아닌거 같음. 여튼 혼자서 풀 때는 이렇게 풀었다. 맞는 건지도 잘 모르겠다. 강의에서는 다음과 같이 풀이했다.

# Bottom-up
x = int(input())

d = [0] * 30001

for i in range(2, x+1):
    d[i] = d[i-1] + 1
    
    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])

x부터 1까지가 아니라 1부터 x까지 d의 value를 하나씩 채워가는 방식으로 풀이했다. 흠 🤔

 

# 이코테 - 효율적인 화폐 구성

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

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

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

 

@solution.py

1로 만들기 문제와 유사하다고 생각이 들어서 참고해서 풀었다. 근데 d[i] == -1 부분이 마음에 안들어 : /

N, M = map(int, input().split())

money = [int(input()) for _ in range(N)]

d = [-1] * 10001 # 1 <= M <= 10,000
for m in money:
    d[m] = 1

for i in range(1,M+1):
    for m in money:
        if i-m >0 and d[i-m] != -1:
            if d[i] == -1:
                d[i] = d[i-m] + 1
            else:
                d[i] = min(d[i], d[i-m] +1)

print(d[M])

 

강의에서는 다음과 같이 풀이했다.

n, m = map(int, input().split())

array = []
for i in range(n):
	array.append(int(input())
    
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:
        	d[j] = min(d[j], d[j-array[i]] +1)
       
if d[m] == 10001:
	print(-1)
else:
	print(d[m]))

 

우선, d 리스트를 -1로 초기화하지 않고 INF, 즉 10,001을 사용했다. (1 <= M <= 10,000 이기 때문에)
또 반복문을 n, 즉 돈 종류 개수를 기준으로 모두 d 리스트를 채우도록 했다.

다이나믹 프로그래밍... To be continued...