์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | ||||||
2 | 3 | 4 | 5 | 6 | 7 | 8 |
9 | 10 | 11 | 12 | 13 | 14 | 15 |
16 | 17 | 18 | 19 | 20 | 21 | 22 |
23 | 24 | 25 | 26 | 27 | 28 | 29 |
30 | 31 |
- C์ธ์ด
- SWEA
- JAVA SPRING
- ์๋ฐ ์คํ๋ง
- php
- ํ์ด์ฌ
- php ํ๋ก๊ทธ๋๋ฐ ์ ๋ฌธ ๋ฌธ์ ํ์ด
- C
- spring
- ์ต๋จ ๊ฒฝ๋ก
- ํ์ ๋ถ๊ธฐ
- php ํ๋ก๊ทธ๋๋ฐ ์ ๋ฌธ ์๋ฃจ์
- php ํ๋ก๊ทธ๋๋ฐ ์ ๋ฌธ ์ฐ์ต๋ฌธ์
- ๋ฐฑ์ค
- ์คํ๋ง
- ํ์ด์ฝ ์ถ์ฒ์ธ
- php ํ๋ก๊ทธ๋๋ฐ ์ ๋ฌธ 3ํ
- ํ๋ฌํฐ
- php ํ๋ก๊ทธ๋๋ฐ ์ ๋ฌธ
- ํ์ด์ฝ ์น๊ตฌ์ฝ๋
- Flutter
- php ํ๋ก๊ทธ๋๋ฐ
- ํ์ด์ฝ ์ด๋์ฝ๋
- Java
- programmers
- ํ๋ฌํฐ ๊ฐ๋ฐํ๊ฒฝ ์ค์
- ๋ฐฐ์ด
- ์๋ฐ
- php ํ๋ก๊ทธ๋๋ฐ ์ ๋ฌธ ์์
- ํ์ด์ฝ ์ถ์ฒ์ธ์ฝ๋
- Today
- Total
ImJay
[BOJ/Java] 7579. ์ฑ ๋ณธ๋ฌธ
๐ [BOJ/Java] 7579. ์ฑ
๐ ๋ฌธ์ ๋งํฌ: ๋ฐฑ์ค 7579๋ฒ - ์ฑ
๐ ๋ฌธ์ ํด์
๐ฑ ์ฌ๋ฌ ๊ฐ์ ์ฑ์ด ์คํ ์ค์ด๋ฉฐ, ์ด๋ฅผ ์ข
๋ฃํ๊ฑฐ๋ ์ผ๋ถ ๋นํ์ฑํํ์ฌ M ๋ฐ์ดํธ ์ด์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ๋ณดํ๋ ์ต์ ๋น์ฉ์ ๊ตฌํ๋ ๋ฌธ์ ์ด๋ค.
๐ฐ ์ฑ์ ๋นํ์ฑํํ ๋ **๋นํ์ฑํ ๋น์ฉ(์ถ๊ฐ ๋ฐฐํฐ๋ฆฌ ์๋น ๋ฑ)**์ด ์กด์ฌํ๋ฉฐ,
๐ ๏ธ ์ต์ํ์ ๋น์ฉ์ผ๋ก M ๋ฐ์ดํธ ์ด์ ํ๋ณดํด์ผ ํ๋ค.
โ ํต์ฌ ๊ฐ๋
- **๋ถ๋ถ ๋ฐฐ๋ญ ๋ฌธ์ (0/1 Knapsack)**๊ณผ ์ ์ฌ
- ์ต์ ์ ์ฑ ๋นํ์ฑํ ์กฐํฉ์ ์ฐพ๋ DP ํ์ฉ
- ๋น์ฉ(cost)์ ๊ธฐ์ค์ผ๋ก ์ต์ ๋น์ฉ์ผ๋ก M ๋ฐ์ดํธ ํ๋ณดํ๋๋ก ์ต์ ํ
๐ ๏ธ ํ์ด ๊ณผ์
1๏ธโฃ ์ ๋ ฅ ์ฒ๋ฆฌ ๋ฐ ์ด๊ธฐํ
- N๊ฐ์ ์ฑ์ **๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋(memory[])**๊ณผ **๋นํ์ฑํ ๋น์ฉ(cost[])**์ ์ ๋ ฅ๋ฐ๋๋ค.
- dp[c]๋ฅผ ์ฌ์ฉํ์ฌ ๋นํ์ฑํ ๋น์ฉ์ด c์ผ ๋ ํ๋ณดํ ์ ์๋ ์ต๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ ์ฅํ๋ค.
- **์ต๋ ๋น์ฉ(C)**์ ๊ณ์ฐํ์ฌ dp ๋ฐฐ์ด์ ํฌ๊ธฐ C + 1๋ก ์์ฑ
2๏ธโฃ 0/1 Knapsack ๋ฐฉ์์ผ๋ก DP ๊ฐฑ์
- ์ฑ์ ํ๋์ฉ ๊ณ ๋ คํ๋ฉฐ, ๋ค์์๋ถํฐ ๋น์ฉ์ ํ์ธํ๋ฉด์ DP ๊ฐฑ์
- dp[j] = max(dp[j], dp[j - cost[i]] + memory[i])
- ๋น์ฉ j๋ฅผ ํ์ฌ ์ฑ์ cost[i]๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ ๊ฐ๋ถํฐ ์ฒ๋ฆฌํด์ผ ์ค๋ณต ์ฌ์ฉ ๋ฐฉ์ง ๊ฐ๋ฅ
3๏ธโฃ M ๋ฐ์ดํธ ์ด์ ํ๋ณดํ ์ ์๋ ์ต์ ๋น์ฉ ์ฐพ๊ธฐ
- dp[j] >= M์ ๋ง์กฑํ๋ ์ต์ j๋ฅผ ์ถ๋ ฅ
๐ป ์ฝ๋ ๊ตฌํ (Java)
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt(); // ์ฑ ๊ฐ์
int M = sc.nextInt(); // ํ๋ณดํด์ผ ํ ๋ฉ๋ชจ๋ฆฌ
int[] memory = new int[N]; // ์ฑ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋
int[] cost = new int[N]; // ์ฑ ๋นํ์ฑํ ๋น์ฉ
int sumCost = 0;
for (int i = 0; i < N; i++) {
memory[i] = sc.nextInt();
}
for (int i = 0; i < N; i++) {
cost[i] = sc.nextInt();
sumCost += cost[i]; // ์ต๋ ๋น์ฉ ๊ณ์ฐ
}
int[] dp = new int[sumCost + 1]; // ๋น์ฉ ๋ณ ์ต๋ ํ๋ณด ๊ฐ๋ฅ ๋ฉ๋ชจ๋ฆฌ ์ ์ฅ
Arrays.fill(dp, 0);
for (int i = 0; i < N; i++) { // ๊ฐ ์ฑ์ ๋ํด DP ๊ฐฑ์
for (int j = sumCost; j >= cost[i]; j--) { // ๋ค์์๋ถํฐ ์
๋ฐ์ดํธ
dp[j] = Math.max(dp[j], dp[j - cost[i]] + memory[i]);
}
}
// M ์ด์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ๋ณดํ ์ ์๋ ์ต์ ๋น์ฉ ์ฐพ๊ธฐ
for (int j = 0; j <= sumCost; j++) {
if (dp[j] >= M) {
System.out.println(j);
break;
}
}
}
}
โฑ๏ธ ์๊ฐ ๋ณต์ก๋ ๋ถ์
๐ O(N × C) (์ต๋ 100 × 10000 = 100๋ง ์ฐ์ฐ)
๐ก dp[j]๋ฅผ ๊ฐฑ์ ํ๋ ๊ณผ์ ์ด O(N × C)์ด๋ฏ๋ก ์ถฉ๋ถํ ํด๊ฒฐ ๊ฐ๋ฅ
๐ก ๋๋์
โ ๋ฐฐ๋ญ ๋ฌธ์ (0/1 Knapsack)์ ์ ์ฌํ ๋ฌธ์ ์์ผ๋ฉฐ,
- ๋ฐฐ์ด์ ๋น์ฉ(cost) ๊ธฐ์ค์ผ๋ก ๊ฐฑ์ ํ๋ ๋ฐฉ์์ ์ตํ ์ ์์๋ค.
- ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ธฐ์ค์ผ๋ก ํ์ง ์๊ณ , ๋น์ฉ์ ๊ธฐ์ค์ผ๋ก DP๋ฅผ ๊ตฌ์ฑํ๋ ์ ์ด ์ฐจ์ด์
โ
์ฑ์ ํ๋์ฉ ๊ณ ๋ คํ๋ฉด์ ๋ค์์๋ถํฐ ์
๋ฐ์ดํธํ๋ ๋ฐฉ์์ด ํต์ฌ์ด์๋ค.
โ
๋น์ฉ์ด ์ต์ํ์ผ๋ก ์ ์ง๋๋๋ก DP ๋ฐฐ์ด์ ์ต์ ํํ๋ ์ ๋ต์ ๋ค์ ๋ณต์ตํ ์ ์์๋ค. ๐
'์๊ณ ๋ฆฌ์ฆ > BOJ - Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[BOJ/Java] 1039. ๊ตํ (0) | 2025.03.10 |
---|---|
[BOJ/Java] 10942. ํฐ๋ฆฐ๋๋กฌ? (0) | 2025.03.10 |
[BOJ/Java] 4991. ๋ก๋ด ์ฒญ์๊ธฐ (0) | 2025.03.10 |
[BOJ/Java] 11049. ํ๋ ฌ ๊ณฑ์ ์์ (0) | 2025.03.10 |
[BOJ/Java] 11066. ํ์ผ ํฉ์น๊ธฐ (0) | 2025.03.10 |