[BOJ] 1010. ๋ค๋ฆฌ ๋๊ธฐ(JAVA)
๐๋ฌธ์
๋ฌธ์
์ฌ์์ด๋ ํ ๋์์ ์์ฅ์ด ๋์๋ค. ์ด ๋์์๋ ๋์๋ฅผ ๋์ชฝ๊ณผ ์์ชฝ์ผ๋ก ๋๋๋ ํฐ ์ผ์ง์ ๋ชจ์์ ๊ฐ์ด ํ๋ฅด๊ณ ์๋ค. ํ์ง๋ง ์ฌ์์ด๋ ๋ค๋ฆฌ๊ฐ ์์ด์ ์๋ฏผ๋ค์ด ๊ฐ์ ๊ฑด๋๋๋ฐ ํฐ ๋ถํธ์ ๊ฒช๊ณ ์์์ ์๊ณ ๋ค๋ฆฌ๋ฅผ ์ง๊ธฐ๋ก ๊ฒฐ์ฌํ์๋ค. ๊ฐ ์ฃผ๋ณ์์ ๋ค๋ฆฌ๋ฅผ ์ง๊ธฐ์ ์ ํฉํ ๊ณณ์ ์ฌ์ดํธ๋ผ๊ณ ํ๋ค. ์ฌ์์ด๋ ๊ฐ ์ฃผ๋ณ์ ๋ฉด๋ฐํ ์กฐ์ฌํด ๋ณธ ๊ฒฐ๊ณผ ๊ฐ์ ์์ชฝ์๋ N๊ฐ์ ์ฌ์ดํธ๊ฐ ์๊ณ ๋์ชฝ์๋ M๊ฐ์ ์ฌ์ดํธ๊ฐ ์๋ค๋ ๊ฒ์ ์์๋ค. (N โค M)
์ฌ์์ด๋ ์์ชฝ์ ์ฌ์ดํธ์ ๋์ชฝ์ ์ฌ์ดํธ๋ฅผ ๋ค๋ฆฌ๋ก ์ฐ๊ฒฐํ๋ ค๊ณ ํ๋ค. (์ด๋ ํ ์ฌ์ดํธ์๋ ์ต๋ ํ ๊ฐ์ ๋ค๋ฆฌ๋ง ์ฐ๊ฒฐ๋ ์ ์๋ค.) ์ฌ์์ด๋ ๋ค๋ฆฌ๋ฅผ ์ต๋ํ ๋ง์ด ์ง์ผ๋ ค๊ณ ํ๊ธฐ ๋๋ฌธ์ ์์ชฝ์ ์ฌ์ดํธ ๊ฐ์๋งํผ (N๊ฐ) ๋ค๋ฆฌ๋ฅผ ์ง์ผ๋ ค๊ณ ํ๋ค. ๋ค๋ฆฌ๋ผ๋ฆฌ๋ ์๋ก ๊ฒน์ณ์ง ์ ์๋ค๊ณ ํ ๋ ๋ค๋ฆฌ๋ฅผ ์ง์ ์ ์๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋ผ.
์ ๋ ฅ
์ ๋ ฅ์ ์ฒซ ์ค์๋ ํ ์คํธ ์ผ์ด์ค์ ๊ฐ์ T๊ฐ ์ฃผ์ด์ง๋ค. ๊ทธ ๋ค์ ์ค๋ถํฐ ๊ฐ๊ฐ์ ํ ์คํธ์ผ์ด์ค์ ๋ํด ๊ฐ์ ์์ชฝ๊ณผ ๋์ชฝ์ ์๋ ์ฌ์ดํธ์ ๊ฐ์ ์ ์ N, M (0 < N โค M < 30)์ด ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
๊ฐ ํ ์คํธ ์ผ์ด์ค์ ๋ํด ์ฃผ์ด์ง ์กฐ๊ฑดํ์ ๋ค๋ฆฌ๋ฅผ ์ง์ ์ ์๋ ๊ฒฝ์ฐ์ ์๋ฅผ ์ถ๋ ฅํ๋ค.
๐ช์์ด๋์ด
- m๊ฐ ์ค n๊ฐ ๋ฝ๊ธฐ(์กฐํฉ)
- m๊ฐ์ ์ซ์ ์ค n๊ฐ๋ฅผ ๋ฝ์ ๋ง๋ค ์ ์๋ ๋ชจ๋ ์กฐํฉ
- ์๋ก ๊ฒน์น๋ฉด ์๋๊ธฐ ๋๋ฌธ์ ์ค๋ณตX, arr[i] < arr[i+1]์ด์ด์ผ ํ๋ค.
- ์กฐํฉ์ ์์์ ์๊ด์๊ธฐ ๋๋ฌธ์ arr[i] < arr[i+1]์ ๊ณ ๋ คํ์ง ์์๋ ๋๋ค.
- nCr = n-1Cr + n-1Cr-1 ๊ณต์ ์ฌ์ฉ
- N์ด 30์ด๊ธฐ ๋๋ฌธ์ ์ฌ๊ท๋ก ํ๋ฉด N!์ผ๋ก ์๊ฐ์ด๊ณผ
- dp๋ฅผ ์ฌ์ฉํ์ฌ ์ค๋ณต๋๋ ๊ณ์ฐ ์ค์ด๊ธฐ
- mem[n-1][r-1] != -1์ด๋ฉด ์ด๋ฏธ ๊ณ์ฐ๋ ๊ฐ์ด๊ธฐ ๋๋ฌธ์ ๊ทธ ๊ฐ์ ๋ฐํ
- mem[n-1][r-1] = combi(n-1, r-1) + combi(n-1, r)๋ก ๊ณ์ฐํ๊ณ mem[n-1][r-1]์ ์ ์ฅ
๐ฅ์ฝ๋
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
import java.io.*;
import java.util.*;
public class Main {
static int[][] mem;
static ArrayDeque<Integer> arr = new ArrayDeque<>();
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int T = Integer.parseInt(br.readLine());
StringBuilder sb = new StringBuilder();
StringTokenizer st;
int N, M;
for (int i = 0; i < T; i++) {
st = new StringTokenizer(br.readLine(), " ");
N = Integer.parseInt(st.nextToken());
M = Integer.parseInt(st.nextToken());
mem = new int[M][N];
for (int j = 0; j < M; j++) {
Arrays.fill(mem[j], -1);
}
sb.append(combi(M,N)).append("\n");
}
System.out.println(sb);
} // end of class
public static int combi(int n, int r) {
if(r == 0 || n == r) {
return 1;
}
if (mem[n - 1][r - 1] != -1) {
return mem[n - 1][r - 1];
}
return mem[n - 1][r - 1] = combi(n - 1, r - 1) + combi(n - 1, r);
}
}// end of main
Comments powered by Disqus.