์ํ ํํ์ DP ๋ฌธ์ ์ด๋ค. N์ ์๋ฅผ ๋๋ ค๊ฐ๋ฉด์ n๋ฒ์งธ ์นธ์ ์ ํํ๊ฑฐ๋, ์ ํํ์ง ์๋ ๊ฒฝ์ฐ์ ์๋ก ๋๋ ์ ์๊ฐํ๋ฉด ๋๋ค. N=4, K=2 ๋ผ๊ณ ๊ฐ์ ํ ๋, ์๋์ ๊ฐ์ด ์๊ฐํด๋ณผ ์ ์๋ค.
๋จผ์ N=4 ๋ฒ์งธ ์นธ์ ์ ํํ์ง ์์ ๊ฒฝ์ฐ์ด๋ค. ์ด ๊ฒฝ์ฐ๋ ์ฌ์ค์ 4์นธ ์ค 1์นธ์ ๋ฌด์กฐ๊ฑด ์ ์ธํ ๋๋จธ์ง 3์นธ ์ค์ 2์นธ์ ๊ณ ๋ฅด๋ ๊ฒฝ์ฐ์ธ๋ฐ, ์ํ 3์นธ์์ 2์นธ์ ๊ณ ๋ฅด๋ ๊ฒฝ์ฐ์ ์๋ 0์ด ๋๋ค. ๊ทธ๋์ ํ์ฌ ์ํฉ์์๋ 0์ด์ง๋ง ์ด์จ๊ฑฐ๋ 4์นธ ์ค 2์นธ์ ๊ณ ๋ฅด๋ ๊ฒฝ์ฐ์ ์์ 3์นธ ์ค 2์นธ์์๋ง ๊ณ ๋ฅด๋ ๊ฒฝ์ฐ์ ์๊ฐ ํฌํจ๋๋ ๊ฒ์ด๋ค.
๋ค์์ N=4 ๋ฒ์งธ ์นธ์ ์ ํํ๋ ๊ฒฝ์ฐ์ด๋ค. ์ด ๊ฒฝ์ฐ๋ ๋ฌด์กฐ๊ฑด ์์ ํ ์นธ์ ๋จ์ดํธ๋ ค ๋๊ณ ์๊ฐํด์ผ ํ๋ค. ๊ฒฐ๊ตญ ์ ํํ ๊ฑด 1์นธ์ด์ง๋ง ์์ ๋จ์ดํธ๋ฆด ํ ์นธ๊น์ง ํฌํจํด์ 2์นธ์ ๋นผ๋๊ณ ๊ณจ๋ผ์ผ ํ๋ ๊ฒ์ด๋ค. ๊ทธ๋ฆฌ๊ณ ์ ํ๋ 1์นธ์ด ์๊ธฐ ๋๋ฌธ์ ๋๋จธ์ง 2์นธ ์ค์์ 1์นธ๋ง ๊ณ ๋ฅด๋ฉด ๋๋ค. ๊ทธ๋์ 2์นธ ์ค 1์นธ์ ๊ณ ๋ฅด๋ ๊ฒฝ์ฐ์ ์ ์ญ์ 4์นธ ์ค 2์นธ์ ๊ณ ๋ฅด๋ ๊ฒฝ์ฐ์ ์์ ํฌํจ๋๋ค.
4์นธ ์ค 2์นธ ๊ณ ๋ฅด๊ธฐ = 3์นธ ์ค 2์นธ ๊ณ ๋ฅด๊ธฐ + 2์นธ ์ค 1์นธ ๊ณ ๋ฅด๊ธฐ
์ ํ์์ผ๋ก ๋ํ๋ด๋ฉด ์๋์ ๊ฐ๋ค.
์ด ๋ฌธ์ ๋ ์ ์ด์ ์์์ 4์นธ ๋ถํฐ ์์ํด์ผ ๋ณ๋ค๋ฅธ ์์ธ์ํฉ ์ฒ๋ฆฌ ์์ด ํ ๋ฒ์ ๊ณ์ฐ๋๋ค. 3์นธ์์ 2์นธ์ ๊ณ ๋ฅด๋ ๊ฒฝ์ฐ๊ฐ ์๋์ผ๋ก 0์ผ๋ก ์ด๊ธฐํ๋๊ธฐ ๋๋ฌธ์ ๋ชจ๋ ์ํฉ์ ์์ฐ์ค๋ฝ๊ฒ ์ํ์ผ๋ก ๊ณ ๋ คํ๊ฒ ๋๊ธฐ ๋๋ฌธ์ด๋ค.
์ฐธ๊ณ ๋ก K ๊ฐ N/2 ๋ณด๋ค ํฐ ๊ฒฝ์ฐ๋ ์์ ๋ถ๊ฐ๋ฅํ๋ฏ๋ก ๋ฐ๋ก 0์ ์ถ๋ ฅํ๋ค.
import java.util.*;
import java.io.*;
public class Main {
static int MOD = 1_000_000_003;
static int sol(int N, int K) {
if (N / 2 < K) {
return 0;
}
int[][] dp = new int[N + 1][K + 1];
for (int i = 1; i <= N; i++) {
dp[i][1] = i;
}
for (int i = 4; i <= N; i++) {
for (int j = 2; j <= K; j++) {
dp[i][j] = (dp[i-1][j] + dp[i-2][j-1]) % MOD;
}
}
return dp[N][K];
}
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int K = sc.nextInt();
System.out.println(sol(N, K));
}
}