https://www.acmicpc.net/problem/17208
๋ฌธ์
์ค๊ฐ๊ณ ์ฌ ์ข ๋ฃ๋ฅผ ๊ธฐ๋ ํด ๊ณํ ์์ด ๋์ ์ฐ๋ ์์์ด๋ ์ํ๊น๊ฒ๋ ํต์ฅ ์๊ณ ๊ฐ 100์๋ ๋จ์ง ์๊ฒ ๋์๊ณ , ๊ฒฐ๊ตญ ์์์ด๋ ์นด์ฐ๋ฒ๊ฑฐ ์ฃผ๋ฐฉ ์๋ฐ๋ฅผ ํ๊ธฐ๋ก ํ๋ค. ์นด์ฐ๋ฒ๊ฑฐ๋ ์น์ฆ๋ฒ๊ฑฐ์ ๊ฐ์ํ๊น์ ํ๋ ์ค์๋ํ๊ต์ ์ ๋ช ํ ์์์ ์ด๋ค.
์๋ฐ ์ฒซ๋ , ์์์ด๊ฐ ์ฃผ๋ฐฉ์ ๋ค์ด์ ์๊ฐ ๊ทธ๋ ๋งค์ฐ ์ค์ํ ์ฌ์ค์ ๊นจ๋ฌ์๋ค. ์ฌ์ค ๊ทธ๋ ์น์ฆ๋ฒ๊ฑฐ๋ ๋ฌผ๋ก ์ด๊ณ ๊ฐ์ํ๊น๋ ๋ง๋ค ์ค ๋ชจ๋ฅธ๋ค๋ ๊ฒ์ด๋ค. ์ด๋ ๋คํํ๋ ์ฃผ๋ฐฉ์๋ ๋๊ตฐ๊ฐ ๋ง๋ค์ด๋ ์น์ฆ๋ฒ๊ฑฐ์ ๊ฐ์ํ๊น์ด ๋ช ๊ฐ ๋จ์์์๊ณ , ์์์ด๋ ํ์ฌ ๋ค์ด์จ ์ฃผ๋ฌธ์ ์ด๊ฑธ ์ด์ฉํด ์ฒ๋ฆฌํ๊ธฐ๋ก ํ๋ค.
๋ชจ๋ ์ฃผ๋ฌธ์ ๊ฐ๊ฐ ์น์ฆ๋ฒ๊ฑฐ ์๊ตฌ ๊ฐ์์ ๊ฐ์ํ๊น ์๊ตฌ ๊ฐ์๋ฅผ ์๋ฏธํ๋ 2๊ฐ์ ์ ์๋ก ์ด๋ฃจ์ด์ง๋ค. ์ด๋ค ์ฃผ๋ฌธ์ ์ฒ๋ฆฌํ๊ธฐ ์ํด์๋ ์น์ฆ๋ฒ๊ฑฐ์ ๊ฐ์ํ๊น์ ์ ํํ ๊ทธ ์ฃผ๋ฌธ์์ ์๊ตฌํ๋ ๋งํผ ์จ์ผ ํ๋ค. ๋ํ ์ฃผ๋ฌธ์ด ๋ค์ด์จ ์์์ ๊ด๊ณ์์ด ์ํ๋ ์ฃผ๋ฌธ์ ์ ํํด ์ฒ๋ฆฌํ ์ ์์ผ๋ฉฐ, ํ๋ฒ ์ฒ๋ฆฌํ ์ฃผ๋ฌธ์ ์ฌ๋ผ์ง๋ฏ๋ก ๊ฐ์ ์ฃผ๋ฌธ์ ๋ค์ ์ฒ๋ฆฌํ๋ ๊ฒ์ ๋ถ๊ฐ๋ฅํ๋ค.
์์ฝ๊ฒ๋ ์ฃผ๋ฐฉ์ ๋จ์์๋ ๊ฒ์ด ๋ง์ง ์๊ธฐ ๋๋ฌธ์ ์ด๋ค ์ฃผ๋ฌธ์ ์ฒ๋ฆฌํ์ง ๋ชปํ ์๋ ์๋ค. ์ต์ ์ ๋ฐฉ๋ฒ์ผ๋ก ์ฃผ๋ฌธ์ ์ ํํด ์ฒ๋ฆฌํ๋ค๋ฉด ์ต๋ ๋ช ๊ฐ์ ์ฃผ๋ฌธ์ ์ฒ๋ฆฌํ ์ ์์๊น?
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์ฃผ๋ฌธ์ ์ N(1 ≤ N ≤ 100), ์ฃผ๋ฐฉ์ ๋จ์ ์น์ฆ๋ฒ๊ฑฐ ๊ฐ์ M(1 ≤ M ≤ 300), ์ฃผ๋ฐฉ์ ๋จ์ ๊ฐ์ํ๊น ๊ฐ์ K(1 ≤ K ≤ 300)๊ฐ ์ฃผ์ด์ง๋ค.
๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์๋ ์ฃผ๋ฌธ ๋ด์ฉ์ ์๋ฏธํ๋ ๋ ์ ์ x, y (1 ≤ x, y ≤ 300)๊ฐ ์ฃผ์ด์ง๋ค. x๋ ์น์ฆ๋ฒ๊ฑฐ ์๊ตฌ ๊ฐ์, y๋ ๊ฐ์ํ๊น ์๊ตฌ ๊ฐ์๋ฅผ ๋ํ๋ธ๋ค.
์ถ๋ ฅ
์ฃผ๋ฐฉ์ ๋จ์ ์น์ฆ๋ฒ๊ฑฐ์ ๊ฐ์ํ๊น์ ์ฌ์ฉํด ์ฒ๋ฆฌํ ์ ์๋ ์ต๋ ์ฃผ๋ฌธ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
ํ์ด
๊ทธ๋ฆผ์ผ๋ก ๊ทธ๋ ค๋ณด๋ฉด,
์ผ๋ก ์ผ์ชฝ ํ์ดํ๋ ์ ํ โผ๏ธ ์ค๋ฅธ์ชฝ ํ์ดํ๋ ์ ํํ์ง ์์โผ๏ธ ์ด๋ค.
DP[ M+1 ][ K+1 ][ N+1] ์ผ๋ก [ ๋จ์ ์น์ฆ๋ฒ๊ฑฐ ๊ฐฏ์ ][๋จ์ ๊ฐ์ํ๊น ๊ฐฏ์ ][ ์ฃผ๋ฌธ ๋ฒํธ ] ์ด๋ค.
Top - Down ๋ฐฉ์์ผ๋ก ํ์๋ค.
๋ค์ ์ฃผ๋ฌธ์ ์น์ฆ๋ฒ๊ฑฐ์ ๊ฐ์ํ๊น ๊ฐฏ์๊ฐ ๋จ์ ๊ฐฏ์๋ณด๋ค ์์ผ๋ฉด ์ ํํ๋ค.
int choose = solve( c - cheeseBurger[idx+1] , f - frenchFry[idx+1], idx+1) + 1 ( idx+1 ๋ฒํธ ์ฃผ๋ฌธ์ ์ ํํ๋ ์๋ฏธ )
int noChoose = solve( c, f, idx+1 ) ( idx + 1 ๋ฒํธ ์ฃผ๋ฌธ์ ์ ํํ์ง ์๋ ๋ค๋ ์๋ฏธ )
idx ๊ฐ ๋ง์ง๋ง ์ฃผ๋ฌธ ๋ฒํธ ( N ) ์ด ๋๋ฉด return 0 ์ ํด์ค๋ค. ์ด๋ ๊ฒ 0 ๋ถํฐ N๊น์ง ํธ์ถํ๊ณ , N๋ฒ ๋ถํฐ return ํด์ฃผ๋ฉด์ ์ต๋๊ฐ์ ๊ตฌํ๋ค.
idx์์๋ choose์ noChoose ์ค ํฐ ๊ฐ์ ์ ํํด์ฃผ์๋ฐ!
DP ๋ฐฐ์ด์ -1 ๋ก ์ด๊ธฐํ ํด์ค ์ด์ ๋ if ( DP > -1) return DP; ํด์ฃผ๊ธฐ ์ํจ์ธ๋ฐ,
์๊ฐ์ด๊ณผ ๋๋ฌธ์ด๋ค.
์ฝ๋
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Main_BOJ_17209_์นด์ฐ๋ฒ๊ฑฐ์๋ฐ์ {
static int[][][] DP;
static int N, M, K;
static int[] cheeseBurger;
static int[] frenchFry;
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer stringTokenizer = new StringTokenizer(br.readLine());
N = Integer.parseInt(stringTokenizer.nextToken());
M = Integer.parseInt(stringTokenizer.nextToken());
K = Integer.parseInt(stringTokenizer.nextToken());
DP = new int[M+1][K+1][N+1];
cheeseBurger = new int[N+1];
frenchFry = new int[N+1];
for(int i = 1 ; i <= N ; i++){
stringTokenizer = new StringTokenizer(br.readLine());
int c = Integer.parseInt(stringTokenizer.nextToken());
int f = Integer.parseInt(stringTokenizer.nextToken());
cheeseBurger[i] = c;
frenchFry[i] = f;
}
for(int i = 0 ; i < M+1 ; i++){
for(int j =0 ; j < K+1 ; j++){
for(int k = 0 ; k < N+1; k++){
DP[i][j][k] = -1;
}
}
}
System.out.println(solve(M, K, 0));
}
private static int solve(int c, int f, int idx) {
if(idx == N)
return 0;
// ์ด ๋ถ๋ถ์ด ์์ผ๋ฉด ์๊ฐ ์ด๊ณผ!
if(DP[c][f][idx] > -1)
return DP[c][f][idx];
int choose = 0;
int noChoose = 0;
if(cheeseBurger[idx+1] <= c && frenchFry[idx+1] <= f){
// idx+1๋ฒ์งธ ์ฃผ๋ฌธ ๋ฐ์
choose = solve(c-cheeseBurger[idx+1], f-frenchFry[idx+1], idx+1) + 1;
}
// idx+1 ๋ฒ์งธ ์ฃผ๋ฌธ ์๋ฐ์
noChoose = solve(c, f, idx+1);
DP[c][f][idx] = Math.max(choose, noChoose);
return DP[c][f][idx];
}
}
'์๊ณ ๋ฆฌ์ฆ > ๋ฐฑ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ ๋ฐฑ์ค / BOJ 14467 ] ์๊ฐ ๊ธธ์ ๊ฑด๋๊ฐ ์ด์ 1 (0) | 2021.09.15 |
---|---|
[ ๋ฐฑ์ค / BOJ 17070 ] ํ์ดํ ์ฎ๊ธฐ๊ธฐ 1 (0) | 2021.09.15 |
[ ๋ฐฑ์ค / BOJ 1958 ] LCS 3 (0) | 2021.09.15 |
[๋ฐฑ์ค / BOJ 12871] ๋ฌดํ ๋ฌธ์์ด (0) | 2021.09.14 |
[๋ฐฑ์ค / BOJ 17406] ๋ฐฐ์ด ๋๋ฆฌ๊ธฐ 4 (0) | 2021.09.14 |