다이나믹 프로그래밍
- 메모리를 적절히 사용하여 수행 시간 효율성을 비약적으로 향상시키는 방법
- 이미 계산된 결과(작은 문제)는 별도의 메모리 영역에 저장하여 다시 계산하지 않도록 함
- top down과 bottom up 방식으로 구성
- 동적계획법이라고도 함
프로그래밍에서 동적의 의미?
- 프로그램이 실행되는 도중에 실행에 필요한 메모리를 할당하는 기법
- 다이나믹 프로그래밍에서 '다이나믹'은 별다른 의미 어벗이 사용됨
다이나믹 프로그래밍 문제?
- 최적 부분 구조 (Optimal Substructure)
- 큰 문제를 작은 문제로 나눌 수 있으며 작은 문제의 답을 모아서 큰 문제 해결
- Top Down 방식
- 중복되는 문제 (Overlapping Subproblem)
- 동일한 작은 문제를 반복적으로 해결
- Bottom up 방식
피보나치수열 (Python)
- 피보나치 수열: 점화식(인접한 항들 사이의 관계식)
def fibo(x):
if x == 1 or x == 2:
return 1
return fibo(x-1) + fibo(x-2)
print(fibo(4)) # 실행결과: 3피보나치수열 (Java)
public class Main{
public static int fibo(int x){
if(x==1 || x==2){
return 1:
}
return fibo(x-1) + fibo(x-2);
}
public static void main(String[] args){
System.out.println(fibo(4));
}
}다이나믹 프로그래밍 구현
메모이제이션 (Memoization)
- top down 방식에서 사용
- 한 번 계산한 결과를 메모리 공간에 메모하는 기법
- 같은 문제가 다시 호출되면 메모했던 결과를 그대로 가져옴
- 캐싱(Caching)이라고도 함
Top Down VS Bottom Up
- Top dowon은 하향식, Bottom Up은 상향식
- 전형적인 형태는 Bottom up 방식
- 결과 저장용 리스트는 DP 테이블
- 메모이제이션은 이전에 계산된 결과를 일시적으로 기록해 놓는 넓은 개념 의미
- DP에만 국한된 개념 아님
피보나치 수열: Top Down 방식 DP (Python)
# 한 번 계산된 결과를 메모이제이션하기 위한 리스트 초기화
d = [0]*100
# 피보나치 함수를 재귀함수로 구현 (Top down)
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)) # 실행 결과: 218922995834555169026피보나치 수열: Bottom Up 방식 DP (Python)
# 앞서 계산된 결과를 저장하기 위한 DP 테이블 초기화
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])# 실행 결과: 218922995834555169026피보나치 수열: Bottom Up 방식 DP (Java)
public static long[] d = new long[100];
public static void main(String[] args){
# 첫번째 피보나치 수와 두번째 피보나치 수는 1
d[1] = 1;
d[2] = 1;
int n = 50; // 50번째 피보나치 수를 계산
// 피보나치 함수 반복문으로 구현(Bottom up)
for (int i = 3; i <= n; i++){
d[i] = d[i-1] + d[i-2];
}
System.out.println(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) # 실행결과: f(6) f(5) f(4) f(3) f(2) f(1) f(2) f(3) f(4)다이나믹 프로그래밍 VS 분할정복
- 모두 최적 부분 구조를 가질 때 사용
- 큰 문제를 작은문제로 나눌 수 있으며 작은 문제의 답을 모아서 큰 문제를 해결
- 차이점: 부분 문제의 중복
- DP의 경우 각 부분 문제들이 서로 영향을 미치며 부분 문제가 중복됨
- 분할 정복의 경우 동일한 부분 문제가 반복으로 계산되지 않음
- 분할 정복 대표 -> 퀵 정렬
- 한 번 기준 원소(Pivot)가 자리를 변경해서 자리를 잡으면 그 기준원소는 위치 바뀌지 않고, 분할 이후에 해당 피벗을 다시 처리하는 부분 문제에서 호출하지 않음
다이나믹 프로그래밍 문제에 접근하는 방법
- 다이나믹 문제인지 유형 파악
- 그리디, 구현, 완전 탐색 등의 아이디어로 문제를 해결할 수 있는 지 검토
- 풀이 방법이 떠오르지 않으면 다이나믹 프로그램이 고려
- 일단 재귀함수로 완전탐색 작성 후 (탑다운) 작은 문제에서 구한 답이 큰 문제에 그대로 사용가능하면, 코드 개선
문제 1: 개미전사
- 식량창고 N개가 주어졌을 때 얻을 수 있는 식량의 최댓값을 구하는 프로그램
문제 해결 방법
- ai = i번째 식량창고까지의 최적의 해 (얻을 수 있는 식량의 최댓값)
- DP 테이블의 값: a0 = 1, a1 = 3, a2 = 3, a3 = 8
답안 (Python)
n = int(input())
array = list(map(int,input().split()))
# 앞서 계산된 결과를 저장하기 위한 DP 테이블 초기화
d = [0]*100
# 다이나믹 프로그래밍 Bottom up
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])답안 (Java)
public static int[] d = new int[100];
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] arr = new int[n];
for (int i = 0; i<n; i++){
arr[i] = sc.nextInt();
}
d[0] = arr[0];
d[1] = Math.max(arr[0], arr[1]);
for (int i = 2; i < n; i++){
d[i] = Math.max(d[i-1],d[i-2]+arr[i]);
}
System.out.println(d[n-1]);
}
}문제 2: 1로 만들기
- 정수 X 가 주어졌을 때, 연산 4개를 적절히 사용하여 값을 1로 만들기
- 연산을 사용하는 횟수의 최솟값 구하기
- 연산:
1. X가 5로 나누어 떨어지면 5로 나누기
2. X가 3으로 나누어 떨어지면 3으로 나누기- X가 2로 나누어 떨어지면 2로 나누기
- X에서 1 빼기
- e.g. 26 -> 25 -> 5 -> 1 => 횟수 3
문제 해결 방법
- ai = i를 1로 만들기 위한 최소 연산 횟수
답안 (Python)
x = int(input())
# x가 30,000까지 들어올 수 있기 때문에 거기에 맞춰서 dp 테이블 초기화
d = [0] * 30001 # 1일 경우 자기자신이 그대로 1이기때문에 연산 수행할 필요없음 -> 0으로 초기화 되어있다고 가정, 2부터 시작
# Bottom up
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])답안 (Java)
public static int[] d = new int[30001];
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
for (int i = 0; i<=x; i++){
d[i] = d[i-1]+1;
if (i%2==0)
d[i] = Math.min(d[i],d[i/2]+1);
if (i%3==0)
d[i] = Math.min(d[i],d[i/3]+1);
if (i%5==0)
d[i] = Math.min(d[i],d[i/5]+1);
}
System.out.println(d[x]);
}
}문제 3: 효율적인 화폐 구성
- N가지 종류의 화폐가 있을 때, M원을 만들기 위한 최소한의 화폐 개수 구하기
문제 해결 방법
- ai = 금액 i를 만들 수 있는 최소한의 화폐 개수
- k = 각 화폐의 단위
- 점화식: k를 하나씩 확인하며
답안 (Python)
n,m = map(int,input().split())
array = []
for i in range(n):
array.append(int(input()))
d = [10001] * (m+1)
d[0] = 0
# Bottom up
for i in range(n): # i는 각각의 화폐단위
for j in range(array[i], m+1): # j는 각각의 금액
if d[j-array[i]] != 10001: # (i-k)원을 만드는 방법이 존재하는 경우
d[j] = min(d[j], d[j-array[i]] + 1)
if d[m] == 10001: # 최종적으로 m원을 만드는 방법이 없는 경우
print(-1)
else:
print(d[m])답안 (Java)
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = sc.nextInt();
}
// DP 테이블 초기화
int[] d = new int[m + 1];
Arrays.fill(d, 10001);
// Bottom up
d[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = arr[i]; j <= m; j++) {
// (i - k)원을 만드는 방법이 존재하는 경우
if (d[j - arr[i]] != 10001) {
d[j] = Math.min(d[j], d[j - arr[i]] + 1);
}
}
}
if (d[m] == 10001) { // 최종적으로 M원을 만드는 방법이 없는 경우
System.out.println(-1);
}
else {
System.out.println(d[m]);
}
}문제 4: 금광
- n x m 크기의 금광이 존재. 맨 처음에는 첫번째 열의 어느 행에서든 출발가능. 이후는 m-1번에 걸쳐서 매번 오른쪽 위, 오른쪽, 오른쪽 아래 3가지 중 하나의 위치로 이동 가능. 채굴자가 얻을 수 있는 금의 최대 크기 구하기
문제 해결 방법
- 모든 위치에서 왼쪽 위에서 오는 경우, 왼쪽 아래에서 오는 경우, 왼쪽에서 오는 경우만 고려 -> 세 가지 경우 중에서 가장 많은 금을 가지고 있는 경우 테이블 갱신
- array[i][j] = i행,j열에 존재하는 금의 양
- dp[i][j] = i행,j열의 최적의 해 (얻을 수 있는 금의 최댓값)
- 리스트의 범위를 벗어나지 않는지 체크
답안 (Python)
# 테스트 케이스 단위로 입력 받기
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]) # 금광정보가 한줄로 들어오기 때문에, m 단위로 데이터를 슬라이싱해서 테이블에 2차원으로 담기
index += m
# dp 진행
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)답안 (Java)
문제 5: 병사 배치하기
- 전투력이 높은 병사가 앞쪽에 오도록 내림차순으로 배치
- 배치 과정에서 특정한 위치에 있는 병사를 열외시키면서 남아있는 병사의 수가 최대가 되도록 하기
- 남아 있는 병사의 수가 최대가 되도록 하기 위해서 열외시켜야하는 병사의 수 구하기
문제 해결 방법
- 가장 긴 증가하는 부분 수열과 동일한 알고리즘
- D[i] = array[i]를 마지막 원소로 가지는 부분 수열의 최대 길이
- 이 문제는 가장 긴 감소하는 부분 수열과 같기 때문에, 먼저 입력받은 병사 정보의 순서를 뒤집기
- 가장 긴 증가하는 부분 수열(LIS) 알고리즘 수행
답안 (Python)
n = int(input())
array = list(map(int,input().split()))
# 순서를 뒤집어 '최장 증가 부분 수열' 문제로 변환
array.revers()
# dp 테이블 초기화
dp = [1] * n # 1 부터 시작
# 가장 긴 증가하는 부분 수열 알고리즘 수행
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))답안 (Java)
static int n;
static ArrayList<Integer> v = new ArrayList<Integer>();
static int[] dp = new int[2000];
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
for (int i = 0; i < n; i++) {
v.add(sc.nextInt());
}
// 순서를 뒤집어 '최장 증가 부분 수열' 문제로 변환
Collections.reverse(v);
// 다이나믹 프로그래밍을 위한 1차원 DP 테이블 초기화
for (int i = 0; i < n; i++) {
dp[i] = 1;
}
// 가장 긴 증가하는 부분 수열(LIS) 알고리즘 수행
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (v.get(j) < v.get(i)) {
dp[i] = Math.max(dp[i], dp[j] + 1);
}
}
}
int maxValue = 0;
for (int i = 0; i < n; i++) {
maxValue = Math.max(maxValue, dp[i]);
}
System.out.println(n - maxValue);
}
Hello!