๋ฌธ์ ๋งํฌ
https://www.acmicpc.net/problem/2225
ํ์ด IDEA
๊ท์น์ ์ฐพ๋ค๊ฐ 2์ฐจ์๋ฐฐ์ด๋ก ํ์ด์ผํ๋ค๋ ์๊ฐ์ ๋ฏธ์ฒ ํ์ง ๋ชปํด์ ์ธํฐ๋ท์ ์ฐธ๊ณ ํ๋ค. dp ๋ ๋ค์ํ ์ ํ์ ํ๋ฉฐ ์ด๋ค ์ํฉ์ผ ๊ฒฝ์ฐ ์ด๋ป๊ฒ ์ ๊ทผํด์ผํ๋์ง ๊ฐ์ ์ตํ์ผํ๋ ๊ฒ ๊ฐ๋ค.
- ๊ท์น์ฐพ๊ธฐ๊ฐ ํ๋ค์๋ค.
- ์ด๋ฐ ๋ฌธ์ ๊ฐ ๋์ค๋ฉด 2์ฐจ์์ผ๋ก ํ์.
- k๊ฐ๋ฅผ ๋ํด์ n์ ๋ง๋๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ฐฐ์ด๋ก ๋ฃ์ผ๋ฉด ๋๋ค.
- 2์ฐจ์ ๋ฐฐ์ด์ผ ๊ฒฝ์ฐ ํ๋ฅผ ๊ทธ๋ฆฌ๋ฉด์ ๊ท์น์ ์ฐพ์๋์๋ฉด ๋๋ค.
- ์๊ฐ๋ณด๋ค ๊ฐ๋จํ ๊ท์น์ด ์๋ค.
- dp๋ ๋ฌด์กฐ๊ฑด ๊ท์น๋ถํฐ!
๊ท์น์ ์ค๋ช ํด๋ณด๊ฒ ๋ค. ์ฐ์ ์์์ ์ ์๊ฒ ์ฒ๋ผ k๊ฐ์ ์๋ฅผ ๋ํด์ n์ ๋ง๋ค์! ๋ผ๋ ๋งฅ๋ฝ์ผ๋ก ์์ํ๊ณ ์ด๋ฅผ dp[k][n] ๋ฐฐ์ด์ ๋ฃ์๋ค. ๊ทธ๋ฆฌ๊ณ ์์ 2๋ฒ ์ผ๋ก ์ฃผ์ด์ง ์์๊ฐ ๊ท์น์ ์ฐพ๊ธฐ์ ์ ์ ํ ๊ฒ ๊ฐ์์, n=6, k=4 ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๊ท์น์ ์ฐพ์๋ณด์๋ค.
๊ท์น์ ๋ฐ๋ผ ํ๋ฅผ ๋ง๋ค์ด๋ณด๋ฉด, ์ฐ์ 1์ฐจ์ ์ผ๋ก ์ด๋ ๊ฒ ๋์จ๋ค. ์ซ์ 1๊ฐ๋ฅผ ๊ฐ๊ณ 1,2,3,4,5,6 ์ ๋ง๋ค ์ ์๋ ๊ฒฝ์ฐ์ ์๋ ๊ฐ๊ฐ 1๊ฐ์ด๋ฉฐ, ์ซ์ 0์ ๋ง๋ค๊ธฐ ์ํ ๊ฒฝ์ฐ์์๋ ๋ชจ๋ 1๊ฐ์ฉ์ด๋ค. (0+0+0=0 ์ด๋๊น!) ์ด๋ฅผ ๋ชจ๋ ์ ์ด ๋ ๋ค, ์๋์ ์ผ๋ก ๊ณ์ฐํ๊ธฐ ์ฌ์ด 2 ๋ฅผ ๋จผ์ ๊ฒฝ์ฐ์์๋ฅผ ์ ์ด๋ณด์.
ํ๋ฅผ ์ฑ์ ๋๊ฐ๋ค ๋ณด๋, ์์ ๊ฐ์ ๊ท์น์ ๋ฐ๊ฒฌํ๋ค. ์๋์ ์ผ๋ก ๊ท์น์ ์ฐพ๊ธฐ ๋ ธ๋์ ๋ถ๋ถ๋ถํฐ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ฐ์ ธ๋ณด๋, [k-1][n] + [n][k-1] ๋ฒ์งธ์ ์๋ ์๋ฅผ ๋ํด์ฃผ๋ฉด ๋ ธ๋์ ๊ฐ์ด ๋์จ๋ค๋ ๊ฒ์ ์ ์ ์์๋ค. ๊ทธ๋ ๊ฒ ๊ณ์ฐ์ฐํ๋ค๋ณด๋ฉด, ์ต์ข ์ ์ธ ๊ฐ ์ซ์ 4๊ฐ๋ฅผ ๋ํด์ 6์ ๋ง๋ค ์ ์๋ ๊ฒฝ์ฐ์์๋ 84๋ก, ์์ ์ ๋์ผํ ๊ฒฐ๊ณผ๊ฐ์ด ๋์จ๋ค๋ ๊ฒ์ ์ ์ ์์๋ค.
์ด๋ ๊ฒ ๊ท์น์ ์ฐพ์์ผ๋ ์ด์ ์ ํ์์ ๊ตฌํด๋ณด์. ์ฒ์ ์๊ฐํ๊ธฐ์๋ ๋งค์ฐ ๋ณต์กํ์ง๋ง, ์ด๋ ๊ฒ ๊ท์น์ ์ฐพ์๋์ผ๋ ๋น๊ต์ ์ด๋ฒ ๋ฌธ์ ์ ์ ํ์์ ์ฝ๋ค. ์ํ๋ ๊ฐ์ ์+์ ๊ฐ์ ๋ํด์ฃผ๋ฉด ๋๋ ๋ง์ด๋ค. ๊ทธ๋ ๊ฒ ๊ตฌํ ์ ํ์์ ์๋์ ๊ฐ๋ค.
dp[k๊ฐ์์๋ก][n๋ง๋ค๊ธฐ] = dp[k-1][n] + dp[k][n-1]
์ด๋ ๊ฒ ๋ง๋ ์ ํ์์ ์์ค์ฝ๋๋ก ๊ทธ๋๋ก ๊ตฌํํ๋ฉด, ์๋์ ๊ฐ๋ค.
์์ค์ฝ๋
์ ๊ทธ๋ฆฌ๊ณ , for ๋ฌธ์์ k๋ 1๋ถํฐ ๋ค์ด๊ฐ ์ ์๊ธฐ ๋๋ฌธ์ 1๋ถํฐ ์งํํด์ฃผ์๋ค. (์ซ์๋ฅผ 0๊ฐ ๋ํ๋ค๋ ๊ฒ์ ๋ง์ด ์๋๊ธฐ ๋๋ฌธ!) ๋๋ถ์ด์, n=0์ผ ๊ฒฝ์ฐ์๋ ๋ณ๋์ ๊ณ์ฐ์์ด ๋ชจ๋ ๊ฒฝ์ฐ์ ์๊ฐ 1์ด๋ฏ๋ก, if ๋ฌธ์ ํ์ฉํ์ฌ 1์ ๋ฃ์ด์ฃผ์๋ค.
let nk = readLine()!.split(separator: " ").map { Int(String($0))! }
var dp = Array(repeating: Array(repeating: 0, count: nk[0]+1), count: nk[1]+1)
// dp[k][n] k๊ฐ ๋ํด์ ๊ฐ์ด n
for k in 1..<nk[1]+1 {
for n in 0..<nk[0]+1 {
if n == 0 {
dp[k][0] = 1
} else {
dp[k][n] = (dp[k-1][n]+dp[k][n-1]) % 1000000000
}
}
}
print(dp[nk[1]][nk[0]])