728x90
www.youtube.com/watch?v=5Lu34WIx2Us&list=PLRx0vPvlEmdAghTr5mXQxGpHjWqSz0dgC&index=6
다이나믹 프로그래밍
-
다이나믹 프로그래밍은 동적 계획법이라고도 부른다
-
일반적인 프로그래밍 분야에서의 동적(Dynamic)이란 어떤 의미를 가질까?
- 자료구조에서 동적 할당(Dynamic Allocation)은 '프로그램이 실행되는 도중에 실행에 필요한
메모리를 할당하는 기법'을 의미한다 - 반면에 다이나믹 프로그래밍에서 '다이나믹'은 별다른 의미 없이 사용된 단어이다
- 자료구조에서 동적 할당(Dynamic Allocation)은 '프로그램이 실행되는 도중에 실행에 필요한
-
다이나믹 프로그래밍은 다음의 조건을 만족할 때 사용할 수 있다
- 최적 부분 구조 (Optimal Substructure)
- 큰 문제를 작은 문제로 나눌 수 있으며 작은 문제로 나눌 수 있으며 작은 문제의 답을 모아서 큰 문제를 해결할 수 있다
- 중복되는 부분 문제 (Overlapping Subproblem)
- 동일한 작은 문제를 반복적으로 해결해야 한다
- 최적 부분 구조 (Optimal Substructure)
피보나치 수열
-
피보나치 수열 다음과 같은 형태의 수열이며, 다이나믹 프로그래밍으로 효과적으로 계산할 수 있다
1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...
-
점화식이란 인접한 항들 사이의 관계식을 의미
-
피보나치 수열을 점화식으로 표현하면 다음과 같음
- 피보나치 수열이 계산되는 과정은 다음과 같이 표현할 수 있다
- 프로그래밍에서는 이러한 수열을 배열이나 리스트를 이용해 표현한다
- 피보나치 수열이 계산되는 과정은 다음과 같이 표현할 수 있다
- 𝑛번째 피보나치 수를 f(𝑛)라고 할 때 4번째 피보나치 수 f(4)를 구하는 과정은 다음과 같다
피보나치 수열: 단순 재귀 소스코드 (Python)
# 피보나치 함수(Fibonacci Function)을 재귀함수로 구현
def fibo(x):
if x == 1 or x == 2:
return 1
return fibo(x - 1) + fibo(x - 2)
print(fibo(4))실행 결과
3피보나치 수열: 단순 재귀 소스코드 (Java)
import java.util.*;
public class Main {
// 피보나치 함수(Fibonacci Function)을 재귀함수로 구현
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));
}
}실행 결과
3피보나치 수열의 시간 복잡도 분석
- 단순 재귀 함수로 피보나치 수열을 해결하면 지수 시간 복잡도를 가지게 된다
- 다음과 같이 𝒇(2) 가 여러 번 호출되는 것을 확인할 수 있다 (중복되는 부분 문제)
- 피보나치 수열의 시간 복잡도는 다음과 같다
- 세타 표기법: 𝜽(1.618・・・ᴺ)
- 빅오 표기법: O(2ᴺ)
- 빅오 표기법을 기준으로 𝒇(30)을 계산하기 위해 약 10억가량의 연산을 수행해야 한다
- 그렇다면 𝒇(100)을 계산하기 위해 얼마나 많은 연산을 수행해야 할까?
피보나치 수열의 효율적인 해법: 다이나믹 프로그래밍
- 다이나믹 프로그래밍의 사용 조건을 만족하는지 확인한다
- 최적 부분 구조: 큰 문제를 작은 문제로 나눌 수 있다
- 중복되는 부분 문제: 동일한 작은 문제를 반복적으로 해결한다
- 피보나치 수열은 다이나믹 프로그래밍의 사용 조건을 만족한다
메모이제이션 (Memoization)
- 메모이제이션은 다이나믹 프로그래밍을 구현하는 방법 중 하나이다
- 한 번 계산한 결과를 메모리 공간에 메모하는 기법이다
- 같은 문제를 다시 호출하면 메모했던 결과를 그대로 가져온다
- 값을 기록해 놓는다는 점에서 캐싱(Caching) 이라고도 한다
탑다운 VS 보텀업
- 탑다운(메모이제이션) 방식은 하향식이라고도 하며 보텀업 방식은 상향식이라고도 한다
- 다이나믹 프로그래밍의 전형적인 형태는 보텀업 방식이다
- 결과 저장용 리스트는 DP 테이블이라고 부른다
- 엄밀히 말하면 메모이제이션은 이전에 계산된 결과를 일시적으로 기록해 놓는 넓은 개념을 의미한다
- 따라서 메모이제이션은 다이나믹 프로그래밍에 국한된 개념은 아니다
- 한 번 계산된 결과를 담아 놓기만 하고 다이나믹 프로그래밍을 위해 활용하지 않을 수도 있다
피보나치 수열: 탑다운 다이나믹 프로그래밍 소스코드 (Python)
# 한 번 계산된 결과를 메모이제이션(Memoization)하기 위한 리스트 초기화
d = [0] * 100
# 피보나치 함수(Fibonacci Function)를 재귀함수로 구현 (탑다운 다이나믹 프로그래밍)
def fibo(x):
# 종료 조건(1 혹은 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피보나치 수열: 탑다운 다이나믹 프로그래밍 소스코드 (Java)
import java.util.*;
public class Main {
// 한 번 계산된 결과를 메모이제이션(Memoization)하기 위한 배열 초기화
public static long[] d = new long[100];
// 피보나치 함수(Fibonacci Function)를 재귀함수로 구현 (탑다운 다이나믹 프로그래밍)
public static long fibo(int x) {
// 종료 조건(1 혹은 2일 때 1을 반환)
if (x == 1 || x == 2) {
return 1;
}
// 이미 계산한 적 있는 문제라면 그대로 반환
if (d[x] != 0) {
return d[x];
}
// 아직 계산하지 않은 문제라면 점화식에 따라서 피보나치 결과 반환
d[x] = fibo(x - 1) + fibo(x - 2);
return d[x];
}
public static void main(String[] args) {
System.out.println(fibo(50));
}
}실행 결과
218922995834555169026피보나치 수열: 보텀업 다이나믹 프로그래밍 소스코드 (Python)
# 앞서 계산된 결과를 저장하기 위한 DP 테이블 초기화
d = [0] * 100
# 첫 번째 피보나치 수와 두 번째 피보나치 수는 1
d[1] = 1
d[2] = 1
n = 99
# 피보나치 함수(Fibonacci Function) 반복문으로 구현(보텀업 다이나믹 프로그래밍)
for i in range(3, n + 1):
d[i] = d[i - 1] + d[i - 2]
print(d[n])실행 결과
218922995834555169026피보나치 수열: 보텀업 다이나믹 프로그래밍 소스코드 (Java)
import java.util.*;
public class Main {
public static long[] d = new long[100];
public static void main(String[] args) {
// 첫 번째 피보나치 수와 두 번째 피보나치 수는 1
d[1] = 1;
d[2] = 1;
int n = 50; // 50번째 피보나치 수를 계산
// 피보나치 함수(Fibonacci Function) 반복문으로 구현(보텀업 다이나믹 프로그래밍)
for (int i = 3; i <= n; i++) {
d[i] = d[i - 1] + d[i - 2];
}
System.out.println(d[n]);
}
}피보나치 수열: 메모이제이션 동작 분석
- 이미 계산된 결과를 메모리에 저장하면 다음과 같이 색칠된 노드만 처리할 것을 기대할 수 있다
- 실제로 호출되는 함수에 대해서만 확인해 보면 다음과 같이 방문한다
- 메모이제이션을 이용하는 경우 피보나치 수열 함수의 시간 복잡도는 O(N) 이다
# 한 번 계산된 결과를 메모이제이션(Memoization)하기 위한 리스트 초기화
d = [0] * 100
# 피보나치 함수(Fibonacci Function)를 재귀함수로 구현 (탑다운 다이나믹 프로그래밍)
def fibo(x):
print('f(' + str(x) + ')', end=' ')
# 종료 조건(1 혹은 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]
fibo(6)실행 결과
f(6) f(5) f(4) f(3) f(2) f(1) f(2) f(3) f(4)다이나믹 프로그래밍 VS 분할 정복
-
다이나믹 프로그래밍과 분할 정복은 모두 최적 부분 구조를 가질 때 사용할 수 있다
- 큰 문제를 작은 문제로 나눌 수 있으며 작은 문제의 답을 모아서 큰 문제를 해결할 수 있는 상황
-
다이나믹 프로그래밍과 분할 정복의 차이점은 부분 문제의 중복이다
- 다이나믹 프로그래밍 문제에서는 각 부분 문제들이 서로 영향을 미치며 부분 문제가 중복된다
- 분할 정복 문제에서는 동일한 부분 문제가 반복적으로 계산되지 않는다
-
분할 정복의 대표적인 예시인 퀵 정렬을 살펴보자
- 한 번 기준 원소(Pivot)가 자리를 변경해서 자리를 잡으면 그 기준 원소의 위치는 바뀌지 않는다
- 분할 이후에 해당 피벗을 다시 처리하는 부분 문제는 호출하지 않는다
다이나믹 프로그래밍 문제에 접근하는 방법
- 주어진 문제가 다이나믹 프로그래밍 유형임을 파악하는 것이 중요하다
- 가장 먼저 그리디, 구현, 완전 탐색 등의 아이디어로 문제를 해결할 수 있는지 검토할 수 있다
- 다른 알고리즘으로 풀이 방법이 떠오르지 않으면 다이나믹 프로그래밍을 고려해 보자
- 일단 재귀 함수로 비효율적인 완전 탐색 프로그램을 작성한 뒤에 (탑다운) 작은 문제에서 구한 답이
큰 문제에서 그대로 사용될 수 있으면, 코드를 개선하는 방법을 사용할 수 있다 - 일반적인 코딩 테스트 수준에서는 기본 유형의 다이나믹 프로그래밍 문제가 출제되는 경우가 많다
<문제> 개미 전사: 문제 설명
- 개미 전사는 부족한 식량을 충당하고자 메뚜기 마을의 식량창고를 몰래 공격하려고 한다. 메뚜기 마을에는
여러 개의 식량창고가 있는데 식량창고는 일직선으로 이어져 있다 - 각 식량창고에는 정해진 수의 식량을 저장하고 있으며 개미 전사는 식량창고를 선택적으로 약탈하여 식량을
빼앗을 예정이다. 이때 메뚜기 정찰병들은 일직선상에 존재하는 식량창고 중에서 서로 인접한 식량창고가
공격받으면 바로 알아챌 수 있다 - 따라서 개미 전사가 정찰병에 들키지 않고 식량창고를 약탈하기 위해서는 최소한 한 칸 이상 떨어진
식량창고를 약탈해야 한다
- 예를 들어 식량창고 4개가 다음과 같이 존재한다고 가정하자
- 이때 개미 전사는 두 번째 식량창고와 네 번째 식량창고를 선택했을 때 최댓값인 총 8개의 식량을 빼앗을
수 있다. 개미 전사는 식량창고가 이렇게 일직선상일 때 최대한 많은 식량을 얻기를 원한다 - 개미 전사를 위해 식량창고 N개에 대한 정보가 주어졌을 때 얻을 수 있는 식량의 최댓값을 구하는 프로그램을
작성하라
<문제> 개미 전사: 문제 해결 아이디어
- 예시를 확인해 봅시다. N = 4일 때, 다음과 같은 경우들이 존재할 수 있다
- 식량을 선택할 수 있는 경우의 수는 다음과 같이 8가지이다
- 7번째 경우에서 8만큼의 식량을 얻을 수 있으므로 최적의 해는 8이다
- 𝒂ᵢ = 𝑖번째 식량창고까지의 최적의 해 (얻을 수 있는 식량의 최댓값)
- 이렇게 정의한다면 다이나믹 프로그래밍을 적용할 수 있다
- 왼쪽부터 차례대로 식량창고를 턴다고 했을 때, 특정한 𝑖번째 식량창고에 대해서 털지 안 털지의 여부를
결정하면, 아래 2가지 경우 중에서 더 많은 식량을 털 수 있는 경우를 선택하면 된다
- 𝒂ᵢ = 𝑖번째 식량창고까지의 최적의 해 (얻을 수 있는 식량의 최댓값)
- 𝑘ᵢ = 𝑖번째 식량창고에 있는 식량의 양
- 점화식은 다음과 같다
- 한 칸 이상 떨어진 식량창고는 항상 털 수 있으므로 (𝑖 - 3)번째 이하는 고려할 필요가 없다
<문제> 개미 전사: 답안 예시 (Python)
# 정수 N을 입력 받기
n = int(input())
# 모든 식량 정보 입력 받기
array = list(map(int, input().split()))
# 앞서 계산된 결과를 저장하기 위한 DP 테이블 초기화
d = [0] * 100
# 다이나믹 프로그래밍(Dynamic Programming) 진행 (보텀업)
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)
import java.util.*;
public class Main {
// 앞서 계산된 결과를 저장하기 위한 DP 테이블 초기화
public static int[] d = new int[100];
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 정수 N을 입력받기
int n = sc.nextInt();
// 모든 식량 정보 입력받기
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = sc.nextInt();
}
// 다이나믹 프로그래밍(Dynamic Programming) 진행(보텀업)
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]);
}
}<문제> 1로 만들기: 문제 설명
- 정수 X가 주어졌을 때, 정수 X에 사용할 수 있는 연산은 다음과 같이 4가지이다
- X가 5로 나누어 떨어지면, 5로 나눈다
- X가 3으로 나누어 떨어지면, 3으로 나눈다
- X가 2로 나누어 떨어지면, 2로 나눈다
- X에서 1을 뺀다
- 정수 X가 주어졌을 때, 연산 4개를 적절히 사용해서 값을 1로 만들고자 한다. 연산을 사용하는 횟수의
최솟값을 출력하라. 예를 들어 정수가 26이면 다음과 같이 계산해서 3번의 연산이 최솟값이다- 26 → 25 → 5 → 1
<문제> 1로 만들기: 문제 조건
<문제> 1로 만들기: 문제 해결 아이디어
- 피보나치 수열 문제를 도식화한 것처럼 함수가 호출되는 과정을 그림으로 그려보면 다음과 같다
- 최적 부분 구조와 중복되는 부분 문제를 만족한다
- 𝒂ᵢ = 𝑖를 1로 만들기 위한 최소 연산 횟수
- 점화식은 다음과 같다
- 단, 1을 빼는 연산을 제외하고는 해당 수로 나누어떨어질 때에 한해 점화식을 적용할 수 있다
<문제> 1로 만들기: 답안 예시 (Python)
# 정수 X를 입력 받기
x = int(input())
# 앞서 계산된 결과를 저장하기 위한 DP 테이블 초기화
d = [0] * 1000001
# 다이나믹 프로그래밍(Dynamic Programming) 진행(보텀업)
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])<문제> 1로 만들기: 답안 예시 (Java)
import java.util.*;
public class Main {
// 앞서 계산된 결과를 저장하기 위한 DP 테이블 초기화
public static int[] d = new int[30001];
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
// 다이나믹 프로그래밍(Dynamic Programming) 진행(보텀업)
for (int i = 2; i <= x; i++) {
// 현재의 수에서 1을 빼는 경우
d[i] = d[i - 1] + 1;
// 현재의 수가 2로 나누어 떨어지는 경우
if (i % 2 == 0)
d[i] = Math.min(d[i], d[i / 2] + 1);
// 현재의 수가 3으로 나누어 떨어지는 경우
if (i % 3 == 0)
d[i] = Math.min(d[i], d[i / 3] + 1);
// 현재의 수가 5로 나누어 떨어지는 경우
if (i % 5 == 0)
d[i] = Math.min(d[i], d[i / 5] + 1);
}
System.out.println(d[x]);
}
}<문제> 효율적인 화폐 구성: 문제 설명
- N가지 종류의 화폐가 있다. 이 화폐들의 개수를 최소한으로 이용해서 그 가치의 합이 M원이 되도록 하려고 한다.
이때 각 종류의 화폐는 몇 개라도 사용할 수 있다 - 예를 들어 2원, 3원 단위의 화폐가 있을 때는 15원을 만들기 위해 3원을 5개 사용하는 것이 가장 최소한의
화폐 개수이다 - M원을 만들기 위한 최소한의 화폐 개수를 출력하는 프로그램을 작성하라
<문제> 효율적인 화폐 구성: 문제 조건
<문제> 효율적인 화폐 구성: 문제 해결 아이디어
-
𝒂ᵢ = 금액 𝑖를 만들 수 있는 최소한의 화폐 개수
-
𝑘 = 각 화폐의 단위
-
점화식: 각 화폐 단위인 𝑘를 하나씩 확인하며
- 𝒂ᵢ₋ₖ를 만드는 방법이 존재하지 않는 경우, 𝒂ᵢ = min(𝒂ᵢ, 𝒂ᵢ₋ₖ + 1)
- 𝒂ᵢ₋ₖ를 만드는 방법이 존재하지 않는 경우, 𝒂ᵢ = INF
-
𝑁 = 3, 𝑀 = 7이고, 각 화폐의 단위가 2, 3, 5인 경우 확인해 보자
-
Step 0 (초기화)
- 먼저 각 인덱스에 해당하는 값을 INF(무한)의 값을 설정한다
- INF은 특정 금액을 만들 수 있는 화폐 구성이 가능하지 않다는 의미를 가진다
- 본 문제에서는 10,001을 사용할 수 있다
- Step 1
- 첫 번째 화폐 단위인 2를 확인한다
- 점화식에 따라서 다음과 같이 리스트가 갱신된다
- Step 2
- 두 번째 화폐 단위인 3을 확인한다
- 점화식에 따라서 다음과 같이 리스트가 갱신된다
- Step 3
- 세 번째 화폐 단위인 5를 확인한다
- 점화식에 따라서 다음과 같이 최종적으로 리스트가 갱신된다
<문제> 효율적인 화폐 구성: 답안 예시 (Python)
# 정수 N, M을 입력 받기
n, m = map(int, input().split())
# N개의 화폐 단위 정보를 입력 받기
array = []
for i in range(n):
array.append(int(input()))
# 한 번 계산된 결과를 저장하기 위한 DP 테이블 초기화
d = [10001] * (m + 1)
# 다이나믹 프로그래밍(Dynamic Programming) 진행(보텀업)
d[0] = 0
for i in range(n):
for j in range(array[i], m + 1):
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)
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 정수 N, M을 입력받기
int n = sc.nextInt();
int m = sc.nextInt();
// N개의 화폐 단위 정보를 입력 받기
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);
// 다이나믹 프로그래밍(Dynamic Programming) 진행(보텀업)
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]);
}
}
}<문제> 금광: 문제 설명
- n × m 크기의 금광이 있다. 금광은 1 × 1 크기의 칸으로 나누어져 있으며, 각 칸은 특정한 크기의
금이 들어 있다 - 채굴자는 첫 번째 열부터 출발하여 금을 캐기 시작한다. 맨 처음에는 첫 번째 열의 어느 행에서든 출발할 수 있다.
이후에 m - 1번에 걸쳐서 매번 오른쪽 위, 오른쪽, 오른쪽 아래 3가지 중 하나의 위치로 이동해야 한다.
결과적으로 채굴자가 얻을 수 있는 금의 최대 크기를 출력하는 프로그램을 작성하라
<문제> 금광: 문제 조건
<문제> 금광: 문제 해결 아이디어
- 금광의 모든 위치에 대하여 다음의 세 가지만 고려하면 된다
- 왼쪽 위에서 오는 경우
- 왼쪽 아래에서 오는 경우
- 왼쪽에서 오는 경우
- 세 가지 경우 중에서 가장 많은 금을 가지고 있는 경우를 테이블에 갱신해주어 문제를 해결한다
- 𝒂𝒓𝒓𝒂𝒚[𝑖][𝒋] = 𝑖행 𝒋열에 존재하는 금의 양
- 𝒅𝒑[𝑖][𝒋] = 𝑖행 𝒋열까지의 최적의 해 (얻을 수 있는 금의 최댓값)
- 점화식은 다음과 같다
- 이때 테이블에 접근할 때마다 리스트의 범위를 벗어나지 않는지 체크해야 한다
- 편의상 초기 데이터를 담는 변수 𝒂𝒓𝒓𝒂𝒚를 사용하지 않아도 된다
- 바로 DP 테이블에 초기 데이터를 담아서 다이나믹 프로그래밍을 적용할 수 있다
<문제> 금광: 답안 예시 (Python)
# 테스트 케이스(Test Case) 입력
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])
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)
result = 0
for i in range(n):
result = max(result, dp[i][m - 1])
print(result)<문제> 금광: 답안 예시 (Java)
import java.util.*;
public class Main {
static int testCase, n, m;
static int[][] arr = new int[20][20];
static int[][] dp = new int[20][20];
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 테스트 케이스(Test Case) 입력
testCase = sc.nextInt();
for (int tc = 0; tc < testCase; tc++) {
// 금광 정보 입력
n = sc.nextInt();
m = sc.nextInt();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
arr[i][j] = sc.nextInt();
}
}
// 다이나믹 프로그래밍을 위한 2차원 DP 테이블 초기화
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
dp[i][j] = arr[i][j];
}
}
// 다이나믹 프로그래밍 진행
for (int j = 1; j < m; j++) {
for (int i = 0; i < n; i++) {
int leftUp, leftDown, left;
// 왼쪽 위에서 오는 경우
if (i == 0) leftUp = 0;
else leftUp = dp[i - 1][j - 1];
// 왼쪽 아래에서 오는 경우
if (i == n - 1) leftDown = 0;
else leftDown = dp[i + 1][j - 1];
// 왼쪽에서 오는 경우
left = dp[i][j - 1];
dp[i][j] = dp[i][j] + Math.max(leftUp, Math.max(leftDown, left));
}
}
int result = 0;
for (int i = 0; i < n; i++) {
result = Math.max(result, dp[i][m - 1]);
}
System.out.println(result);
}
}
}<문제> 병사 배치하기: 문제 설명
-
N명의 병사가 무작위로 나열되어 있다. 각 병사는 특정한 값의 전투력을 보유하고 있다
-
병사를 배치할 때는 전투력이 높은 병사가 앞쪽에 오도록 내림차순으로 배치를 하고자 한다.
다시 말해 앞쪽에 있는 병사의 전투력이 항상 뒤쪽에 있는 병사보다 높아야 한다 -
또한 배치 과정에서는 특정한 위치에 있는 병사를 열외시키는 방법을 이용한다.
그러면서도 남아 있는 병사의 수가 최대가 되도록 하고 싶다 -
예를 들어, N = 7일 때 나열된 병사들의 전투력이 다음과 같다고 가정한다
- 이때 3번 병사와 6번 병사를 열외시키면, 다음과 같이 남아 있는 병사의 수가 내림차순의 형태가 되며 5명이 된다.
이는 남아 있는 병사의 수가 최대가 되도록 하는 방법이다
- 병사에 대한 정보가 주어졌을 때, 남아 있는 병사의 수가 최대가 되도록 하기 위해서 열외시켜야 하는 병사의 수를
출력하는 프로그램을 작성하라
<문제> 병사 배치하기: 문제 조건
<문제> 병사 배치하기: 문제 해결 아이디어
-
이 문제의 기본 아이디어는 가장 긴 증가하는 부분 수열(Longest Increasing Subsequence, LIS)로
알려진 전형적인 다이나믹 프로그래밍 문제의 아이디어와 같다 -
예를 들어 하나의 수열 𝒂𝒓𝒓𝒂𝒚 = {4,2,5,8,4,11,15}이 있다고 하자
- 이 수열의 가장 긴 증가하는 부분 수열은 {4,5,8,11,15}이다
-
본 문제는 가장 긴 감소하는 부분 수열을 찾는 문제로 치환할 수 있으므로, LIS 알고리즘을 조금 수정하여
적용함으로써 정답을 도출할 수 있다 -
가장 긴 증가하는 부분 수열 (LIS) 알고리즘을 확인해 보자
-
𝐷[𝑖] = 𝒂𝒓𝒓𝒂𝒚[𝑖]를 마지막 원소로 가지는 부분 수열의 최대 길이
-
점화식은 다음과 같다
- 가장 먼저 입력 받은 병사 정보의 순서를 뒤집는다
- 가장 긴 증가하는 부분 수열 (LIS) 알고리즘을 수행하여 정답을 도출한다
<문제> 병사 배치하기: 답안 예시 (Python)
n = int(input())
array = list(map(int, input().split()))
# 순서를 뒤집어 '최장 증가 부분 수열' 문제로 변환
array.reverse()
# 다이나믹 프로그래밍을 위한 1차원 DP 테이블 초기화
dp = [1] * n
# 가장 긴 증가하는 부분 수열(LIS) 알고리즘 수행
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)
import java.util.*;
public class Main {
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);
}
}728x90
'CodingTest' 카테고리의 다른 글
| [이것이 코딩 테스트다] 8. 기타 그래프 이론 (0) | 2020.10.10 |
|---|---|
| [이것이 코딩 테스트다] 7. 최단 경로 알고리즘 (0) | 2020.10.10 |
| [이것이 코딩 테스트다] 5. 이진 탐색 (0) | 2020.10.04 |
| [이것이 코딩 테스트다] 4. 정렬 알고리즘 (0) | 2020.10.04 |
| [이것이 코딩 테스트다] 3. DFS & BFS (0) | 2020.10.03 |
댓글