[BaekJoon] 1010 ๋ค๋ฆฌ๋๊ธฐ JAVA
๐ ๋ฐฑ์ค 1010 ๋ฌธ์ https://www.acmicpc.net/problem/1010
๋ฌธ์
์ฌ์์ด๋ ํ ๋์์ ์์ฅ์ด ๋์๋ค. ์ด ๋์์๋ ๋์๋ฅผ ๋์ชฝ๊ณผ ์์ชฝ์ผ๋ก ๋๋๋ ํฐ ์ผ์ง์ ๋ชจ์์ ๊ฐ์ด ํ๋ฅด๊ณ ์๋ค. ํ์ง๋ง ์ฌ์์ด๋ ๋ค๋ฆฌ๊ฐ ์์ด์ ์๋ฏผ๋ค์ด ๊ฐ์ ๊ฑด๋๋๋ฐ ํฐ ๋ถํธ์ ๊ฒช๊ณ ์์์ ์๊ณ ๋ค๋ฆฌ๋ฅผ ์ง๊ธฐ๋ก ๊ฒฐ์ฌํ์๋ค. ๊ฐ ์ฃผ๋ณ์์ ๋ค๋ฆฌ๋ฅผ ์ง๊ธฐ์ ์ ํฉํ ๊ณณ์ ์ฌ์ดํธ๋ผ๊ณ ํ๋ค. ์ฌ์์ด๋ ๊ฐ ์ฃผ๋ณ์ ๋ฉด๋ฐํ ์กฐ์ฌํด ๋ณธ ๊ฒฐ๊ณผ ๊ฐ์ ์์ชฝ์๋ N๊ฐ์ ์ฌ์ดํธ๊ฐ ์๊ณ ๋์ชฝ์๋ M๊ฐ์ ์ฌ์ดํธ๊ฐ ์๋ค๋ ๊ฒ์ ์์๋ค. (N โค M)
์ฌ์์ด๋ ์์ชฝ์ ์ฌ์ดํธ์ ๋์ชฝ์ ์ฌ์ดํธ๋ฅผ ๋ค๋ฆฌ๋ก ์ฐ๊ฒฐํ๋ ค๊ณ ํ๋ค. (์ด๋ ํ ์ฌ์ดํธ์๋ ์ต๋ ํ ๊ฐ์ ๋ค๋ฆฌ๋ง ์ฐ๊ฒฐ๋ ์ ์๋ค.) ์ฌ์์ด๋ ๋ค๋ฆฌ๋ฅผ ์ต๋ํ ๋ง์ด ์ง์ผ๋ ค๊ณ ํ๊ธฐ ๋๋ฌธ์ ์์ชฝ์ ์ฌ์ดํธ ๊ฐ์๋งํผ (N๊ฐ) ๋ค๋ฆฌ๋ฅผ ์ง์ผ๋ ค๊ณ ํ๋ค. ๋ค๋ฆฌ๋ผ๋ฆฌ๋ ์๋ก ๊ฒน์ณ์ง ์ ์๋ค๊ณ ํ ๋ ๋ค๋ฆฌ๋ฅผ ์ง์ ์ ์๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋ผ.
์ ๋ ฅ
์ ๋ ฅ๊ณผ ์ฒซ ์ค์๋ ํ ์คํธ ์ผ์ด์ค์ ๊ฐ์ T๊ฐ ์ฃผ์ด์ง๋ค. ๊ทธ ๋ค์ ์ค๋ถํฐ ๊ฐ๊ฐ์ ํ ์คํธ ์ผ์ด์ค์ ๋ํด ๊ฐ์ ์์ชฝ๊ณผ ๋์ชฝ์ ์๋ ์ฌ์ดํธ์ ๊ฐ์ ์ ์ N, M (0 < N <= M < 30) ์ด ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
๊ฐ ํ ์คํธ ์ผ์ด์ค์ ๋ํด ์ฃผ์ด์ง ์กฐ๊ฑด ํ์ ๋ค๋ฆฌ๋ฅผ ์ง์ ์ ์๋ ๊ฒฝ์ฐ์ ์๋ฅผ ์ถ๋ ฅํ๋ค.
ํ์ด
์ผ๋จ ์ด ๋ฌธ์ ๋ฅผ ๋ฑ ๋ดค์๋ ๋ ๊ฒฝ์ฐ์ ์์ ์ค๋ณต์ด ํ๋ฝ๋์ง ์๋๋ค๋ ๋ถ๋ถ์์ ์กฐํฉ์ ๋ ์ฌ๋ ธ๋ค.
์กฐํฉ
n ๊ฐ์ ์์ ์ค ์์๋ฅผ ๊ณ ๋ คํ์ง ์๋ ๊ฒฝ์ฐ์ ์. ์ฆ, ์ค๋ณต์ ์ ๊ฑฐํ ์์ด์ด๋ผ๊ณ ๋ณผ ์ ์๋ค.
nCr = nโโCrโโ + nโโCr
์กฐํฉ์ ์์ ๊ฐ์ ๊ณต์์ ๊ฐ๊ณ ์๋๋ฐ ์ด๋,
ํ๋์ ์์๋ฅผ ์ ํํ ๊ฒฝ์ฐ + ํ๋์ ์์๋ฅผ ์ ํํ์ง ์์ ๊ฒฝ์ฐ๋ก ๋ํ๋ผ ์ ์๋ค.
์๋ฅผ ๋ค๋ฉด [1, 2, 3, 4, 5] ๊ฐ ์์ ๋ 3๊ฐ๋ฅผ ๋ฝ๋ ๊ฒฝ์ฐ๋ฅผ ๊ตฌํ๋ค๊ณ ํ๋ฉด
- 5๋ฅผ ๋ฏธ๋ฆฌ ์ ํํ ๊ฒฝ์ฐ : ๋จ์ ์ [1, 2, 3, 4]. ์ ํ๋ ์ [5]
- ๋จ์ ์ ์ค 2๊ฐ๋ฅผ ์ ํํ ์ ์๋ ๊ฒฝ์ฐ = [1, 2, 5], [1, 3, 5], [1, 4, 5], [2, 3, 5], [2, 4, 5], [3, 4, 5]. ์ด 6๊ฐ
- 5๋ฅผ ์ ํํ์ง ์์ ๊ฒฝ์ฐ : ๋จ์ ์ [1, 2, 3, 4]
- ๋จ์ ์ ์ค 3๊ฐ๋ฅผ ์ ํํ ์ ์๋ ๊ฒฝ์ฐ = [1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]. ์ด 4๊ฐ
์ฆ, 5Cr = 4C2 + 4C3 = 10๊ฐ๊ฐ ๋๋ค.
๋ฝ์์ผ ํ ๊ฐ์์ธ r์ด 0์ด ๋๋ฉด ์ ํ์ ์ฌ์ง๊ฐ ์์ผ๋ฏ๋ก 1์ ๋ฆฌํด์ํจ๋ค.
์ ์ฒด ๊ฐ์์ ๋ฝ์์ผ ํ ๊ฐ์๊ฐ ๊ฐ๋ค๋ฉด ์ด ๋ํ ์ ํ์ ์ฌ์ง๊ฐ ์์ผ๋ฏ๋ก 1์ ๋ฆฌํด์ํจ๋ค.
๊ทธ๋ฆฌ๊ณ 0.5 ์ด๋ผ๋ ์๊ฐ ์ ํ์ด ์๊ธฐ์ Dynamic Programming ์๊ณ ๋ฆฌ์ฆ ๊ธฐ๋ฒ์ Top-down ์ ํ์ฉํ์ฌ ์ํ ์๊ฐ ํจ์จ์ฑ์ ํฅ์์์ผ์ฃผ์๋ค.
๋์ ๊ณํ๋ฒ Dynamic Programming
DP ์๊ณ ๋ฆฌ์ฆ ๊ธฐ๋ฒ์ ์ด๋ฏธ ๊ณ์ฐ๋ ๊ฒฐ๊ณผ๋ฅผ ๋ณ๋์ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ์ ์ฅํ์ฌ ๋ค์ ๊ณ์ฐํ์ง ์๋๋ก ์ค๊ณํ์ฌ ์ํ ์๊ฐ ํจ์จ์ฑ์ ํฅ์์ํค๋ ๋ฐฉ๋ฒ์ด๋ค.
Top-down ํํฅ์
์์ ๋ฌธ์ ํด๊ฒฐ์ ์ํด ํ์ ๋ฌธ์ ๋ฅผ ์ฌ๊ท๋ก ํธ์ถํ์ฌ ํ์ ๋ฌธ์ ๋ถํฐ ์์ ๋ฌธ์ ๊น์ง ์์ฐจ์ ์ผ๋ก ํด๊ฒฐํ๋ ๋ฐฉ์. ํด๊ฒฐํด๋์ ํ์ ๋ฌธ์ ๋ฅผ ์ ์ฅํ๊ธฐ ์ํด Memoization์ด ์ฌ์ฉ๋๋ค.
Memoization
ํ๋ฒ ๊ณ์ฐํ ๊ฒฐ๊ณผ๋ฅผ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๋ฉ๋ชจํ๋ ๊ธฐ๋ฒ.
๋ฉ๋ชจ์ด์ ์ด์ ์ฌ์ฉ์ ํตํด ๋ชจ๋ ๋ฌธ์ ๊ฐ ๋จ ํ๋ฒ์ฉ๋ง ๊ณ์ฐ๋๋ค๊ณ ๋ณด์ฅ๋๊ธฐ์ ํจ์ ํธ์ถ ํ์๊ฐ ๊ฐ์๋๋ค.
๋ด๊ฐ ํผ ์ฝ๋
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import java.io.*;
import java.util.StringTokenizer;
public class Main {
private static final int[][] dp = new int[30][30]; // ๋ฉ๋ชจ์ด์ ์ด์
์ํ ํ๋ ฌ, ๊ตฌํ ๊ฐ์ ๋ฐ๋ก ์ ์ฅํด๋๋ค
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
int T = Integer.parseInt(br.readLine());
for (int i = 0; i < T; i++) {
StringTokenizer st = new StringTokenizer(br.readLine(), " ");
int N = Integer.parseInt(st.nextToken());
int M = Integer.parseInt(st.nextToken());
bw.write(recursive(M, N) + "\n");
}
bw.flush();
bw.close();
}
// M ์์ N์ ๋ฝ๋ ๊ฒฝ์ฐ์ ์
private static int recursive(int n, int r) {
/**
* ๋ฉ๋ชจ์ด์ ์ด์
O(n)
* ํ๋ฒ ๊ตฌํ ๊ฐ์ ์ ์ฅ๋ ๊ฐ ๋ฆฌํด
*/
if (dp[n][r] > 0) {
return dp[n][r];
}
else if (n == r || r == 0) {
return dp[n][r] = 1;
}
else {
/**
* Combination ์กฐํฉ
* nCr = n-1Cr-1 + n-1Cr
* (n-1Cr-1) : ํ๋์ ์์๋ฅผ ์ ํํ ๊ฒฝ์ฐ
* (n-1Cr) : ํ๋์ ์์๋ฅผ ์ ํํ์ง ์์ ๊ฒฝ์ฐ
*/
return dp[n][r] = recursive(n - 1, r - 1) + recursive(n - 1, r);
}
}
}
์ฐธ๊ณ ๋ธ๋ก๊ทธ https://woongsios.tistory.com/179 https://loosie.tistory.com/150
