olrlobt
[JAVA/๋ฐฑ์ค ๊ณจ๋5] #2294 ๋์ 2 ๋ณธ๋ฌธ
https://www.acmicpc.net/problem/2294
๐ ๊ณจ๋5 - #2294 ๋์ 2
๐ ํ ์คํธ์ผ์ด์ค ์ถ๊ฐ ํํธ
2 15
3
5
= 3
2 15
2
1
= 8
โ๏ธ ํ์ด๋ฒ
๋ํ์ ์ธ DP ๋ฌธ์ ์ด๊ณ , ์ด ์ ํฌ์คํธ์ธ ๋์ 1 ๋ฌธ์ ์ ๋น์ทํ๊ฒ ์๊ฐํ ์ ์๋ค.
DP ๋ฌธ์ ๋ฅผ ํ ๋, ๊ฐ์ฅ ๋จผ์ ๊ณ ๋ คํด์ผ ํ ๊ฒ์
์บ์ฑ์ ํตํ ์ ํ์ ๋์ถ์ด๋ค.
์บ์ฑ์ ์ํด DP ํ ์ด๋ธ์ ๊ทธ๋ ค๋ณด๋ฉด,
๊ฐ๋ก์ถ์ K์์ด ๋๊ธฐ ์ํ ๊ฐ์น๋ฅผ ๋์ดํ ์ ์๋ค.
๊ทธ๋ฆฌ๊ณ ์ธ๋ก์ถ์ ๋์ ์ ํ๋์ฉ ์ถ๊ฐํ๋ฉฐ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด ๋ณด์.
๋จผ์ , 1์์ง๋ฆฌ ๋์ ์ ์ถ๊ฐํด ์ค๋ค.
์ฒซ ๋์ ๋ง์ผ๋ก๋ ์ ํ์์ ๋์ถํ๊ธฐ ์ด๋ ค์ฐ๋ฏ๋ก, ๋ค์ ๋์ ์ผ๋ก ๋์ด๊ฐ๋ค.
5์์ง๋ฆฌ ๋์ ์ ์ถ๊ฐํด ์ฃผ๊ฒ ๋๋ฉด, 4์๊น์ง๋ ์บ์์ ์ํฅ์ ๋ฏธ์น์ง ์๋๋ค.
์ดํ, 5์์ ๋ง๋ค ๋๋ถํฐ๋ 5์์ง๋ฆฌ ๋์ ์ ์ฌ์ฉํ ์ ์๊ฒ ๋๋ฏ๋ก, ์ฌ์ฉํ๋ ๋์ ์ ๊ฐ์๊ฐ ์ค๊ฒ ๋๋ค.
๋ฐ๋ผ์, 5์์ง๋ฆฌ ๋์ ์ ํ๋ ์ด์ ์ฌ์ฉํด์ ๋ง๋ค ๊ฒฝ์ฐ๋ฅผ ๊ตฌํด์ค๋ค.
๋จผ์ 5์์ ๋ง๋๋ ๊ฒฝ์ฐ.
5์์ ํ๋ ์ด์ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์,
๋ง๋ค๊ณ ์ ํ๋ ๊ฐ 5์์ ํ์ฌ ๋์ ์ ๊ฐ์น์ธ 5๋ฅผ ๋นผ์ฃผ๊ณ , ๊ทธ ๊ฐ์ ์บ์์์ ์ฐพ๋๋ค.
์ด ๋ง์ ์ฆ, dp [5 - 5]๋ฅผ ์ฐพ์๋ด๊ณ 5๋ฅผ ํ๋ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ 1์ ๋ํด์ค๋ค.
๋ฐ๋ผ์ ์ฌ๊ธฐ๊น์ง๋ง ๋ณด์์ ๋์ ์ ํ์์,
dp [ i ] = dp [ i - coin [index] ] + 1
๋ง์ฐฌ๊ฐ์ง๋ก 10์ ์ด์์ ๋ง๋ค ๋, 5์์ง๋ฆฌ ๋์ ์ 2๊ฐ ์ด์ ์ฌ์ฉํ ์ ์์ผ๋ฏ๋ก, ๋ค์๊ณผ ๊ฐ์ด ์ฑ์์ง๊ฒ ๋๋ค.
์์ ์ ํ์์ ํ ๋๋ก 12์์ ๋ง๋๋ ๊ฒฝ์ฐ๋ฅผ ๋ณด๋ฉด,
๋ง๋ค๊ณ ์ ํ๋ 12์์์, ํ์ฌ ๋์ ์ ํ๋ ํฌํจํ๊ธฐ ๋๋ฌธ์ ๋์ ์ ๊ฐ์น๋ฅผ ๋นผ์ค๋ค. 12-5=7.
๋ฐ๋ผ์ dp [7]์ 1์ ๋ํ๋ฉด 4๊ฐ ๋์ถ๋๋ค.
dp [12] = 4
๋๋จธ์ง ๊ฒฝ์ฐ๋ ๋ง์ฐฌ๊ฐ์ง๋ก ์ฑ์์ฃผ๋ฉด ๋๋ค.
๋ค์์ผ๋ก 12์์ง๋ฆฌ ๋์ ์ ์ถ๊ฐํ๋ค.
12์ ์ญ์ ์์ ์ ํ์์ผ๋ก ๊ฐ์ ๋์ถํ๋ฉด,
13์์ ๋ง๋ค๊ณ ์ ํ ๋,
๋ง๋ค๊ณ ์ ํ๋ 13์์์, ํ์ฌ ๋์ ์ ํ๋ ์ด์ ํฌํจํ๋ฏ๋ก, 13-12=1.
dp [1] + 1 = 2์ ๊ฐ์ ๋์ถํ๋ค.
14 ์ญ์
14-12=2 ์ด๋ฏ๋ก,
dp [2] + 1 = 3์ ๊ฐ์ด ๋์จ๋ค.
๊ทธ๋ฆฌ๊ณ ๊ฐ์ฅ ์ค์ํ 15๋ฅผ ๋ณด์.
๋ง๋ค๊ณ ์ ํ๋ 15์์ 12๋ฅผ ํ๋ ์ด์ ํฌํจํ๋ฏ๋ก, 15-12=3.
dp [3] = 3 ์ด๋ฏ๋ก
dp [15] = 3+1 = 4์ ๊ฐ. ์ฆ, ์๋ ์ ์ฅ๋์ด ์๋ 3์ ๊ฐ๋ณด๋ค ํฐ ๊ฐ์ด ๋์ค๊ฒ ๋๋ฏ๋ก,
๊ธฐ์กด ์บ์์ ๊ฐ๊ณผ ๋น๊ตํด์ ์ต์๊ฐ์ ๋์ถํด์ผ ํ๋ค.
๋ฐ๋ผ์ ์ต์๊ฐ์ ๋์ถํ๋ ์ ํ์์ ๋ค์๊ณผ ๊ฐ์ด ๋์ถํ ์ ์๋ค.
dp [ i ] = Math.min( dp [ i ], dp [ i - coin [index] ] + 1)
ํ์ง๋ง Math.min์ ์ฌ์ฉํ๊ฒ ๋๋ฉด, ๋ฐฐ์ด ์ ์ธ ์ ์ด๊ธฐํ ๊ฐ์ธ 0์ ๊ฐ์ด ๊ณ์ ๋ค์ด๊ฐ๊ฒ ๋ ๊ฒ์ด๋ค.
์ด ์์์์๋, ์ฒซ ๋์ ์ด 1์์ด์๊ธฐ ๋๋ฌธ์ ๋ ๋ฒ์งธ ๋์ ๊ณผ ์ธ ๋ฒ์งธ ๋์ ์์ ๋ฌธ์ ๊ฐ ๋ฐ์ํ์ง ์์ง๋ง,
ํ ์คํธ์ผ์ด์ค ์ถ๊ฐ ํํธ๋ฅผ ๋ณด๋ฉฐ, ์ด๋ป๊ฒ ํด๊ฒฐํด์ผ ํ ์ง ๊ฐ์ ์ก์๋ณด์.
2 15
3
5
= 3
์ฒซ ๋์ ์ธ 3์์ ๊ฒฝ์ฐ๋ ์์๋ก ์ ์ฌ์ง๊ณผ ๊ฐ์ด ์ฑ์ธ ์ ์๋ค.
๋ ๋ฒ์งธ ๋์ ์ธ 5์์ ์ถ๊ฐํ๋ฉด, 5์์ด ์ฌ์ฉ๋๊ธฐ ์ ๊น์ง๋ ์ด ์ ์ ์บ์๋ฅผ ๊ฐ์ ธ์จ๋ค.
์ฌ๊ธฐ์ 5์์ ๋ง๋ค๊ธฐ ์ํด, ์ ํ์ dp [ i ] = Math.min( dp [ i ], dp [ i - coin [index] ] + 1)๋ฅผ ์ฌ์ฉํ๊ฒ ๋๋ฉด,
5์์ 1๊ฐ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ๊ฐ ์์ผ๋ฏ๋ก, ๋ต์ด 1์ด ๋์ด์ผ ํ์ง๋ง
Math.min์ ์ํด ์ด์ ์บ์ ๊ฐ์ธ 0์ด ์ฑ์์ง๊ฒ ๋๋ค.
๊ทธ๋ ๋ค๋ฉด 0์ด ์๋, 1์ด ์ฑ์์ง๊ฒ ํ๊ธฐ ์ํด์๋ ์ด๋ป๊ฒ ํด์ผ ํ ๊น?
๋ฐฉ๋ฒ์ ์๊ฐ๋ณด๋ค ๊ฐ๋จํ๋ค.
0์ด ์ฑ์์ง๋ ์ด์ ๋ ๋ฐฐ์ด์ ์ด๊ธฐ๊ฐ์ด 0์ธ๋ฐ Math.min์ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ด๋ค.
๋ฐ๋ผ์, ๋ฐฐ์ด์ ์ด๊ธฐ ๊ฐ์ ํฐ ๊ฐ์ผ๋ก ์ด๊ธฐํํด์ฃผ๋ฉด ๋ฌธ์ ๋ ํด๊ฒฐ๋๋ค.
ํด๋น ๋ฌธ์ ๋ "๋์ ์ ๊ฐ์น๋ 100,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๋ค"๋ผ๋ ์กฐ๊ฑด์ด ์์ผ๋ฏ๋ก, 100,001๋ก ์ด๊ธฐํํด์ฃผ๋ฉด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ค.
๐๏ธ JAVA ํ์ด
import java.util.Arrays;
import java.util.Scanner;
public class baekjoon2294 {
static int K;
static int[] dp;
static int[] coin;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
K = sc.nextInt();
coin = new int[N];
dp = new int[K + 1];
Arrays.fill(dp,100001);
for (int testCase = 0; testCase < N; testCase++) {
coin[testCase] = sc.nextInt();
}
solve();
}
public static void solve() {
dp[0] = 0;
for (int index = 0; index < coin.length; index++) {
for (int i = coin[index]; i <= K; i++) {
dp[i] = Math.min(dp[i], dp[i - coin[index]] + 1);
}
}
if (dp[K] == 100001) {
dp[K] = -1;
}
System.out.println(dp[K]);
}
}
'Algorithm > ๋ฐฑ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๋ฐ/๋ฐฑ์ค ๊ณจ๋5] #2293 ๋์ 1 (0) | 2023.01.10 |
---|---|
[์๋ฐ/๋ฐฑ์ค ๊ณจ๋5] #12865 ํ๋ฒํ ๋ฐฐ๋ญ (0) | 2023.01.09 |
[์๋ฐ/๋ฐฑ์ค ๊ณจ๋5] #1461 ๋์๊ด (1) | 2023.01.02 |
[์๋ฐ/๋ฐฑ์ค ๊ณจ๋5] #13164 ํ๋ณต ์ ์น์ (1) | 2023.01.01 |
[์๋ฐ/๋ฐฑ์ค ๊ณจ๋3] #13904 ๊ณผ์ (0) | 2022.12.31 |