๐ก ์กฐ๊ฑด
- NรN ๊ฒ์ํ์ ์๊ฐ ์ ํ์ ธ ์๋ค.
N (4 โค N โค 100)
- ์ด ๊ฒ์์ ๋ชฉํ๋ ๊ฐ์ฅ ์ผ์ชฝ ์ ์นธ์์ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ์๋ ์นธ์ผ๋ก ๊ท์น์ ๋ง๊ฒ ์ ํ๋ฅผ ํด์ ๊ฐ๋ ๊ฒ์ด๋ค.
๊ฐ ์นธ์ ์ ํ์๋ ์๋ ํ์ฌ ์นธ์์ ๊ฐ ์ ์๋ ๊ฑฐ๋ฆฌ๋ฅผ ์๋ฏธํ๋ค.
์นธ์ ์ ํ์๋ ์๋ 0๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 9๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ์์ด๋ฉฐ, ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ์๋ ์นธ์๋ ํญ์ 0์ด ์ฃผ์ด์ง๋ค.
- ๋ฐ๋์ ์ค๋ฅธ์ชฝ์ด๋ ์๋์ชฝ์ผ๋ก๋ง ์ด๋ํด์ผ ํ๋ค.
0์ ๋ ์ด์ ์งํ์ ๋ง๋ ์ข
์ฐฉ์ ์ด๋ฉฐ, ํญ์ ํ์ฌ ์นธ์ ์ ํ์๋ ์๋งํผ ์ค๋ฅธ์ชฝ์ด๋ ์๋๋ก ๊ฐ์ผ ํ๋ค.
- ํ ๋ฒ ์ ํ๋ฅผ ํ ๋, ๋ฐฉํฅ์ ๋ฐ๊พธ๋ฉด ์ ๋๋ค.
์ฆ, ํ ์นธ์์ ์ค๋ฅธ์ชฝ์ผ๋ก ์ ํ๋ฅผ ํ๊ฑฐ๋, ์๋๋ก ์ ํ๋ฅผ ํ๋ ๋ ๊ฒฝ์ฐ๋ง ์กด์ฌํ๋ค.
- ๊ฐ์ฅ ์ผ์ชฝ ์ ์นธ์์ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ์๋ ์นธ์ผ๋ก ๊ท์น์ ๋ง๊ฒ ์ด๋ํ ์ ์๋ ๊ฒฝ๋ก์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ๋ฌธ์ .
- DP ์ ํ์ ๋ฌธ์
๐ ์์ ๋ฐ ์คํ๊ฒฐ๊ณผ
์์
4
2 3 3 1
1 2 1 3
1 2 3 1
3 1 1 0
์คํ๊ฒฐ๊ณผ
3
โจ๏ธ ๋ฌธ์ ํ์ด
- ๊ฒฝ๋ก์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ์ด๋ค. ์ด ๋ฌธ์ ๋ ํ๋ํ๋ ๊ฒฝ๋ก๋ฅผ ์ดํด๋ณด๊ธฐ ์ํด์ dfs๋ฅผ ์ฌ์ฉํ ๊ฒฝ์ฐ, ์๊ฐ๋ณต์ก๋๊ฐ ๋งค์ฐ ํฌ๊ฒ ๋์จ๋ค.
- ๋ค์ด๋๋ฏนํ๋ก๊ทธ๋๋ฐ ์๊ณ ๋ฆฌ์ฆ์ ์ด์ฉํ์ฌ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด์ผํ๋๋ฐ, ์ฐ๋ฆฌ๋ ๋ฌธ์ ์์ ์๋์ ๊ฐ์ ์กฐ๊ฑด์ ์ฃผ๋ชฉ์ ํด์ ํ๋ฉด ์ฝ๊ฒ ์๊ฐํด๋ณผ ์ ์๋ ๋ฌธ์ ์ด๋ค.
์นธ์ ์ ํ์๋ ์๋ 0๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 9๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ์์ด๋ฉฐ, ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ์๋ ์นธ์๋ ํญ์ 0์ด ์ฃผ์ด์ง๋ค.
๋ฐ๋์ ์ค๋ฅธ์ชฝ์ด๋ ์๋์ชฝ์ผ๋ก๋ง ์ด๋ํด์ผ ํ๋ค.
0์ ๋ ์ด์ ์งํ์ ๋ง๋ ์ข
์ฐฉ์ ์ด๋ฉฐ, ํญ์ ํ์ฌ ์นธ์ ์ ํ์๋ ์๋งํผ ์ค๋ฅธ์ชฝ์ด๋ ์๋๋ก ๊ฐ์ผ ํ๋ค.
- (0, 0)์์ ์์ํด (n - 1, n - 1) ๊น์ง ๊ฐ๋ ๊ฒฝ์ฐ์ ์๋ฅผ DP ๋ฆฌ์คํธ์ ์ ์ฅํด๋๊ฐ๋ฉด์ ๋ฐ๋ณต๋ฌธ์ ํตํด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ค๋ฉด,
์๊ฐ๋ณต์ก๋๋ ์ฝ O(N * N) ์ด ๋์จ๋ค. ์ต์
์ ๊ฒฝ์ฐ๋ฅผ ๊ณ ๋ คํ๋๋ผ๋ ์ต๋ ์ฝ 10,000 ์ ๋๋ฐ์ ์๊ฑธ๋ฆฐ๋ค.
DP ๋ฆฌ์คํธ๋ n * n ํฌ๊ธฐ์ ๋ฆฌ์คํธ๋ก ๋ง๋ค๊ณ , (0, 0)์ 1๋ก ์ด๊ธฐํํ๋ค.
- 2์ค for ๋ฌธ์ ์ฌ์ฉํ์ฌ, ๋ง์ฝ ํ์ฌ ์์นํ ๊ณณ์ด (n - 1, n - 1) ์ด๋ผ๋ฉด dp[i][j]๋ฅผ ์ถ๋ ฅํ๋ฉด ๋๋ค.
- (4)๋ฒ์ ๊ฒฝ์ฐ๊ฐ ์๋๋ผ๋ฉด, (i, j)์ ํด๋นํ๋ arr์ ๊ฐ์ cur ๋ผ๋ ๋ณ์์ ์ ์ฅํ๋ค.
ํ์ฌ ์์น์ธ (i, j) ์์ ์ฐ์ธก์ผ๋ก cur ๋งํผ ์ด๋์ ํ ์ ์๋ค๋ฉด, dp[i][j + cur]์ dp[i][j]๋ฅผ ๋ํด์ค๋ค.
ํ์ฌ ์์น์ธ (i, j) ์์ ํ๋จ์ผ๋ก cur ๋งํผ ์ด๋์ ํ ์ ์๋ค๋ฉด, dp[i + cur][j]์ dp[i][j]๋ฅผ ๋ํด์ค๋ค.
๐ฅ ์์ค ์ฝ๋
from sys import stdin
n = int(stdin.readline())
arr = []
for _ in range(n):
arr.append(list(map(int, stdin.readline().split())))
dp = [[0] * n for _ in range(n)]
dp[0][0] = 1
for i in range(n):
for j in range(n):
if i == n - 1 and j == n - 1:
print(dp[i][j])
break
cur = arr[i][j]
if j + cur < n:
dp[i][j + cur] += dp[i][j]
if i + cur < n:
dp[i + cur][j] += dp[i][j]