๐ ๋ฌธ์
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! ๋๋ ํญ์ ์ด๋ ค์!!!
์ฌ๊ท๋ก ํ๋ฉด ์๊ฐ์ด๊ณผ๊ฐ ๋๋ค. ๊ฒฝํ๋ด์ด๋ค....์ฝ๋์ ๋ฌธ์ ๊ฐ ์๋๋ฐ ์๊ฐ์ด๊ณผ๋ผ๋ ๊ฒ์ ์ฆ DP๋ฅผ ์ฐ๋ผ๋ ๋ป์ด๋ค.
DP๋ก ์ ๊ทผํ๋ฉด, ์ ํ์ ์ธ ๋ ์ ๋ฌธ์ ์ด๋ค.
๐ก knapsack(idx, b, f): ์ฃผ๋ฌธ๋ฒํธ idx๊ฐ ๋ค์ด์์ ๋ b๊ฐ์ ๋ฒ๊ฑฐ, f๊ฐ์ ํ๋ผ์ด๊ฐ ๋จ์์๋ ๊ฒฝ์ฐ ์ฒ๋ฆฌํ ์ ์๋ ์ต๋ ์ฃผ๋ฌธ๊ฐ์๋ฅผ ๋ฆฌํด.
๐ก DP[idx][b][f]: knapsack์์ ๋ฆฌํดํ๊ณ ์ ํ๋ ๊ฐ์ ์ ์ฅํ๋ ๋ฉ๋ชจ์ด์ ์ด์ ๋ฐฐ์ด
0: (10,10) | 1: (10,50) | 2: (20,30) | 3: (20,30) | 4: (15, 10) |
์๋ฅผ ๋ค์ด ์ด 100๊ฐ์ ๋ฒ๊ฑฐ์ 100๊ฐ์ ํ๋ผ์ด๊ฐ ์์ ๋, ๋ค์ด์จ ์ฃผ๋ฌธ๋ค์ (๋ฒ๊ฑฐ, ํ๋ผ์ด)๊ฐ์ด ์์ ๊ฐ๋ค๊ณ ์๊ฐํด๋ณด์.
์ฃผ๋ฌธ 0๋ฒ์ ์ฒ๋ฆฌํ๋ค๋ฉด ๋จ์ (๋ฒ๊ฑฐ, ํ๋ผ์ด)๋ (90,90)์ด ๋ ๊ฒ์ด๋ค.
์ฃผ๋ฌธ 1๋ฒ์ ๋ ๊ฐ์ ๊ธฐ๋ก์ ๋์ธ๋ค. ์ฃผ๋ฌธ์ ์ฒ๋ฆฌํ๋๋/ ์ฒ๋ฆฌํ์ง ์๋๋.
์ฃผ๋ฌธ 1๋ฒ์ ์ฒ๋ฆฌํ๋ค๋ฉด ๋จ๋ (๋ฒ๊ฑฐ, ํ๋ผ์ด)๋ (80,30)์ผ๋ก, ์ดํ ์ฒ๋ฆฌํ ์ ์๋ ์ฃผ๋ฌธ์ ๊ฐ์๋ 2๋ฒ๋ง ์ ํํ๊ฑฐ๋/3๋ฒ๋ง ์ ํํ๊ฑฐ๋/4๋ฒ๋ง ์ ํํ๊ฑฐ๋, ์ด 1๊ฐ๊ฐ ๋ ๊ฒ์ด๋ค. ๋ฐ๋ผ์ knapsack(1,90,90)์ 1๋ฒ ์ฃผ๋ฌธ์ฒ๋ฆฌ 1+์ดํ ์ฃผ๋ฌธ๋ค ์ต๋ ์ฒ๋ฆฌ๊ฐ์ 1์ ๋ํด 2๊ฐ ๋๋ค.
์ฃผ๋ฌธ 1๋ฒ์ ์ฒ๋ฆฌํ์ง ์๋๋ค๋ฉด, ๋ค์ด์จ (๋ฒ๊ฑฐ, ํ๋ผ์ด)๊ฐ (90,90)์ ๊ทธ๋๋ก ๋ค๊ณ ๋ค์ ์ฃผ๋ฌธ๋ค์ ์ฒ๋ฆฌํ๋ฌ ๊ฐ๋ค. ์ด๋ ๋๊ธด (90,90)์ ๊ฐ์ ์ฃผ๋ฌธ 2,3,4๋ฒ์ ๋ชจ๋ ๋ฐ์ ์ ์๋ ์์ด๋ฏ๋ก, ์ดํ ์ฒ๋ฆฌํ ์ ์๋ ์ฃผ๋ฌธ์ ๊ฐ์๋ 3์ด ๋ฆฌํด๋๋ค. ๋ฐ๋ผ์ knapsack(1,90,90)์ 1๋ฒ ์ฃผ๋ฌธ์ฒ๋ฆฌ 0+์ดํ ์ฃผ๋ฌธ๋ค ์ต๋ ์ฒ๋ฆฌ ๊ฐ์ 3์ ๋ํ์ฌ ์ด 3์ด ๋๋ค.
์ฃผ๋ฌธ 1๋ฒ์ ์ด ๋ ๊ฐ์ง ์ํ ์ค ๊ฐ์ฅ ์ต๋๊ฐ์ ๋ฆฌํดํ๋ ๊ฐ์ ์ฐพ์ dp[1][90][90]์ ์ ์ฅํ๊ณ ์ด๋ฅผ ๋ฆฌํดํ๋ค. ์ ์์์์๋ 3์ด ๋ ๊ฒ์ด๋ค.
์ด ๋ฆฌํด๊ฐ์ ๊ณ ์ค๋ํ ์ฃผ๋ฌธ 0๋ฒ์ผ๋ก ๋์๊ฐ๋ค.
์์ ์ ์์๋ ์ฃผ๋ฌธ 0๋ฒ์ "์ฒ๋ฆฌํ์ ๋"๋ฅผ ๊ฐ์ ์ผ๋ก ํ ๊ฒ์ด์๋ค. ์ฃผ๋ฌธ 0๋ฒ์ ํด๋น ์ฃผ๋ฌธ์ ์ฒ๋ฆฌํ์ง ์์ ๊ฒฝ์ฐ์, (0๋ฒ ์ฃผ๋ฌธ ์ฒ๋ฆฌ ๊ฐ์ 1+์ดํ ์ฃผ๋ฌธ๋ค ์ต๋ ์ฒ๋ฆฌ ๊ฐ์ 3)์ธ ๊ฐ 4๋ฅผ ๋น๊ตํ์ฌ ๊ทธ ์ค ์ต๋๊ฐ์ ์ ์ฅํ๊ฒ ๋๋ค.
๐ป ์์ค์ฝ๋: ์๋ฐ(Java)
public class Main_๋ฐฑ์ค_17208_์นด์ฐ๋ฒ๊ฑฐ์๋ฐ์_๊ณจ๋IV {
static int N, M, K, result=Integer.MIN_VALUE;
static int[][] order;
static int[][][] dp;
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
N = Integer.parseInt(st.nextToken()); //order
M = Integer.parseInt(st.nextToken()); //burgers
K = Integer.parseInt(st.nextToken()); //fries
order = new int[N][2];
dp = new int[N][301][301];
for (int i = 0; i < N; i++) {
st = new StringTokenizer(br.readLine());
order[i][0] = Integer.parseInt(st.nextToken()); //burger
order[i][1] = Integer.parseInt(st.nextToken()); //fri
}//input
// ํน์ order๊ฐ ๋จ์ ๊ฐ์ํ๊น์ผ๋ก ์ฒ๋ฆฌํ ์ ์์ ๋: ์ฃผ๋ฌธ์ ๋ฐ๊ฑฐ๋/ ์๋ฐ๊ฑฐ๋
// takeOrder(0, 0, 0, 0); ์๊ฐ์ด๊ณผ
System.out.println(knapsack(0, M, K));;
}//end of main
static private void takeOrder(int bSum, int fSum, int idx, int cnt) {
if(idx==N) {
result = Math.max(cnt, result);
return;
}
int burger = order[idx][0];
int fri = order[idx][1];
if(bSum+burger<=M && fSum+fri<=K) {
takeOrder(bSum+burger, fSum+fri, idx+1, cnt+1);
}
takeOrder(bSum, fSum, idx+1, cnt);
}//end of takeOrder
static private int knapsack(int idx, int b, int f) {
if(idx==N) return 0;
int burger = order[idx][0];
int fri = order[idx][1];
if(dp[idx][b][f] != 0) return dp[idx][b][f];
int orderCnt = knapsack(idx+1, b, f);
if(burger<=b && fri<=f) {
orderCnt = Math.max(knapsack(idx+1, b-burger, f-fri)+1, orderCnt);
}
return dp[idx][b][f] = orderCnt;
}//end of knapsack
}//end of class
๐ ๐ ๐
๏ผฐ๏ฝ๏ฝ๏ฝ๏ฝ ๏ฝ ๏ผข๏ฝ ๏ผณ๏ผก๏ผน
๐๐ฉ๐ข๐ฏ๐ฌ๐ด ๐ง๐ฐ๐ณ ๐ณ๐ฆ๐ข๐ฅ๐ช๐ฏ๐จ