[BOJ][๐ก5][๋ฐฑ์ค#23083] ๊ฟ๋ฒ ์น์ฐ์ด
์์ฑ:    
์ ๋ฐ์ดํธ:
์นดํ ๊ณ ๋ฆฌ: BOJ Gold V
๋ฌธ์ ์ถ์ฒ
๋ฌธ์
์ด์ธ๊ณ์ ์น์ฐ์ด๋ ๊ฟ๋ฒ์ด๋ค. ์น์ฐ์ด๊ฐ ์ฌ๋ ๋ฒ์ง์ ์กฐ๊ธ ํน์ดํ ๊ตฌ์กฐ๋ก ๋์ด์๋ค. ๋ฒ์ง์ (N)ํ (M)์ด์ ๊ฒฉ์๋ก ์ด๋ฃจ์ด์ ธ ์๊ณ , ๊ฐ ์นธ์ ์ ์ก๊ฐํ ๋ชจ์์ด๋ค. ๊ฐ์ ํ์ ์์นํย ๋ ์นธ์ ๋น๊ตํ์ ๋, ์ง์ ๋ฒ์งธ ์ด์ ์นธ์ ํ์ ๋ฒ์งธ ์ด์ ์นธ๋ณด๋ค ๋ฐ ์นธ ์๋์ ์์นํด ์๋ค. ์๋ ๊ทธ๋ฆผ์ 3ํ 4์ด์ ๊ฒฉ์๋ก ์ด๋ฃจ์ด์งย ๋ฒ์ง์ ์์์ด๋ค.
๋ ์ก๊ฐํ ์นธ์ด ํ๋์ ๋ณ์ ๊ณต์ ํ๊ณ ์๋ค๋ฉด ์๋ก ์ธ์ ํ๋ค๊ณ ํ๋ค. ์ก๊ฐํ ์นธ์ ๊ฐ ๋ณ์๋ ์ธ์ ํ ์นธ์ผ๋ก ์ด๋ํ ์ ์๋ ๋ฌธ์ด ์๋๋ฐ, ๋ฒ์ง ๋ด ๊ตํต ์ ๋ฆฌ๋ฅผ ์ํด ๊ฐ ์นธ์์๋ ์๋์ชฝ, ์ค๋ฅธ์ชฝ ์, ์ค๋ฅธ์ชฝ ์๋ย ์นธ์ผ๋ก๋ง ์ด๋ํ ์ ์๋ค. ๋, ๋ฒ์ง์๋ ๊ตฌ๋ฉ ์นธ์ด ์์ ์๋ ์๋๋ฐ,ย ๊ตฌ๋ฉ ์นธ์ผ๋ก๋ ์ด๋ํ ์ ์๋ค. ์น์ฐ์ด๋ ์ต๊ทผ ๊ฟ๋ฒ๋ค ์ฌ์ด์ ๊ธ์๋๋ก ์ ์ผ๋๊ณ ์๋ ๋ณ์ด ๋ฐ์ด๋ฌ์ค๋ฅผ ํผํ๊ธฐ ์ํด ๋ฒ์ง์ฝ ์ํ์ ํ๊ณ ์๋ค. ์ฌ์ฌํจ์ด ๊ทน์ ๋ฌํ ์น์ฐ์ด๋ ๋ฒ์ง์ (1)ํ (1)์ด ์นธ์์ (N)ํ (M)์ดย ์นธ๊น์ง ๋ฐ๊นฅ์ผ๋ก ๋๊ฐ์ง ์๊ณ ์ด๋ํ๋ ๊ฒฝ๋ก์ ๊ฐ์๊ฐ ์๊ณ ์ถ์ด ์ก๋ค. ์๊ฐ ๊ฒฉ๋ฆฌ ์ค์ธ ์น์ฐ์ด๊ฐ ๋ ์ด์ ๋ต๋ตํ์ง ์๋๋ก ๊ฒฝ๋ก์ ๊ฐ์๋ฅผ ์ธ์ ์๋ ค์ฃผ์!
์ ๋ ฅ
์ฒซ์งธ ์ค์ (N), (M)์ด ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋์ด ์ฃผ์ด์ง๋ค. ๋ค์ ์ค์๋ ๊ตฌ๋ฉ ์นธ์ ๊ฐ์ (K)๊ฐ ์ฃผ์ด์ง๋ค. ์ด์ด์ (K)๊ฐ ์ค์ ๊ตฌ๋ฉ ์นธ์ ์ ๋ณด (x_i), (y_i)๊ฐ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋์ด ์ฃผ์ด์ง๋ค. ์ด๋ (i)๋ฒ์งธ ๊ตฌ๋ฉ ์นธ์ด (x_i)ํ (y_i)์ด์ ์กด์ฌํจ์ ๋ปํ๋ค. ๋ชจ๋ ๊ตฌ๋ฉ ์นธ์ ์์น๋ ์๋ก ๋ค๋ฅด๋ค. (1)ํ (1)์ด ์นธ ๋๋ (N)ํ (M)์ด ์นธ์ด ๊ตฌ๋ฉ์ธ ๊ฒฝ์ฐ๋ ์์์ด ๋ณด์ฅ๋๋ค.
์ถ๋ ฅ
๋ฒ์ง์ (1)ํ (1)์ด ์นธ์์ (N)ํ (M)์ด ์นธ์ผ๋ก ์ด๋ํ๋ ๊ฒฝ๋ก์ ๊ฐ์๋ฅผ (10^9+7)๋ก ๋๋ ๋๋จธ์ง๋ฅผ ์ถ๋ ฅํ๋ค.
์ ํ
2 โค (N) โค 1,000 2 โค (M) โค 1,000 0 โค (K) โค min((NM) - 2, 104) 1 โค (x_i) โค (N) 1 โค (y_i)ย โค (M)
์์
์ ๋ ฅ
3 4
1
2 3
์ถ๋ ฅ
20
My Sol
import sys
input = sys.stdin.readline
sys.setrecursionlimit(300000)
def main():
def make_holes():
K = int(input())
for _ in range(K):
i, j = map(int, input().split())
dp[i][j] = 0
def find_dp(i, j):
if dp[i][j] != -1: return dp[i][j]
val = find_dp(i-1, j)+find_dp(i, j-1)
val += find_dp(i-1, j-1) if j%2 else find_dp(i+1, j-1)
dp[i][j] = int(val%X)
return dp[i][j]
X = 1e9+7
I, J = map(int, input().split())
dp = [[-1]*(J+1) for _ in range(I+2)]
dp[1][1] = 1
for i in range(I+1):
dp[i][0] = 0
for j in range(J+1):
dp[0][j] = 0
dp[I+1][j] = 0
make_holes()
return find_dp(I, J)
print(main())
DP๋ฅผ ์ฌ์ฉํ๋ ๋ฌธ์ ์๋ค. ๊ณจ๋5 DP๋ฌธ์ ์น๊ณ ๋ ์๊ฐ์ด๊ณผ ์ด์๋ก ์ต์ ํ๋ฅผ ์ต๋ํ ํ ๋ค์์ผ ํ ์ ์์๋ ๊น๋ค๋ก์ด ๋ฌธ์ ์๋ค.
- ๊ธฐ๋ณธ์ ์ผ๋ก dp 2์ฐจ์ ๋ฐฐ์ด์ 0์ผ๋ก ์ด๊ธฐํํ๋ ํธ์ธ๋ฐ, ๊ฒฝ๊ณ๊ฐ์์ ๋ฐ๋ก 0์ returnํ๋ ๊ฒ์ ๋ฒ์ ์กฐ๊ฑด์ด ์๋ ์ด๊ธฐํ ๊ฐ์ด ์๋ ๊ฒ์ผ๋ก ํ๊ธฐ ์ํด -1๋ก ์ด๊ธฐํํ๊ณ ๊ฒฝ๊ณ๋ฅผ 0์ผ๋ก ์ด๊ธฐํํด ์ข ๋ฃ ์กฐ๊ฑด์ผ๋ก ํ์๋ค.
- (1, 1) ์ขํ๋ฅผ 1๋ก ๋๊ณ , dp๋ (I, J)๋ถํฐ ์กฐํํด์ ์ค์ฌ๋๊ฐ๋ค. ์ด๋ฅผ
find_dp
ํจ์๋ก ์์ฑํด์ memoizationํ์๋ค. dp[i][j]
์ ๊ฐ์ด ์ด๊ธฐ๊ฐ์ธ -1์ด ์๋๋ผ๋ฉด ๋ฐ๋ก returnํ๊ณ ์๋๋ผ๋ฉด ํด๋น ์ขํ๊น์ง ๋๋ฌํ๊ธฐ ์ํ ๊ฒฝ์ฐ์ ์dp[i-1][j]
,dp[i][j-1]
๋ฅผ ๋ํด์ค๋ค. ์ฌ๊ธฐ์ ๋ฒ์ง ๋ชจ์ ๊ณ์ฐ์ ๊ด๊ฑด์ธj
์ด์ ํ์ง ์ฌ๋ถ๋ฅผ ํ์ธํ์ฌdp[i-1][j-1]
๋๋dp[i+1][j-1]
๋ฅผ ๋ํด์ค ๋คdp
๋ฐฐ์ด์ memoizationํ ๋ค ๋ฐํํ๋ค.
๊ฒฐ๊ณผ
๋ง์์ต๋๋ค!!
๋๊ธ๋จ๊ธฐ๊ธฐ