๊ณจ๋4 : dp & DFS ๋ฌธ์ ์ด๋ค.
ํ์ด
์ด๊ฒ.. ์ ๊ทผ ๋ฐฉ์์ ์ฝ๊ฐ ๋ฐ๋๋กํด์ ์ค๋๊ฑธ๋ ธ๋ค. ๋ฐํ ์ ๋ฐฉ์์ผ๋ก ์ฌ๊ณ ๋ฅผ ํ์ฌ, ๋ง์ง๋ง ์ง์ ๊น์ง ๊ฐ๋๋ฐ ์์ด 4๋ฐฉํฅ์ ๊ฒฝ๋ก๋ฅผ ๋ํด์ฃผ์ด์ผ ํ๋ค๊ณ ์๊ฐํ๋ค. ๊ทธ๋ฐ๋ฐ ๊ทธ๋ ๊ฒ ์๊ฐ์ ํ๋ ์ฝ๊ฒ ์ ํ์์ด ๋ ์ค๋ฅด์ง ์์๋ค.
์ด๋ด ๋๋ ์ผ๋จ ๊ธฐ๋ณธ์ ์ธ ๊ณจ์์ธ ๊ทธ๋ํ ๋ฐฉ๋ฒ์ ํด๊ฒฐ๋ฐฉ์๋ถํฐ ์ถ๋ฐํ๋ ๊ฒ์ด ์ข๋ค. ์ฆ, ์ผ๋จ ์ด ๋ฌธ์ ๋ DFS ํ์ ๋ฌธ์ ๋ผ ์๊ฐํ๋ฉด ํธํ๋ค. ๊ทธ๋ฌ๋ 250000 ํฌ๊ธฐ์ ํ์ด๊ณ , ๊ทธ๋ฅ ํ ๊ฒฝ์ฐ ๋น์ฐํ ์๊ฐ์ด๊ณผ๊ฐ ๋ ๊ฒ์ด๋ค.
๊ทธ๋ผ ์ผ๋จ ๊ธฐ๋ณธ์ ์ธ DFS๋ ์ด๋ค ๋ฐฉ์์ธ๊ฐ? ํน์ ์์น์์ ๋ค์ ์์น๋ฅผ ๊ตฌํ๊ณ , DFS๋ฅผ ๋ค์ ๋๋ฆฌ๋ ๋ฐฉ์์ด๋ค. ์ฌ๊ธฐ์ ํํธ๋ฅผ ์ป์ด์ผ ํ๋ค. ํด๋น ์์น์์์ ๊ฒฝ๋ก๋ ๋ค์ ์์น์์ ๊ตฌํ ๊ฒฝ๋ก๋ค์ ํฉ์ผ๋ก ๊ตฌ์ฑ๋๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ์ด๋ฌํ DFS์ ํ์ด ๋ฐฉ๋ฒ์ dp๋ฅผ ์ ์ฉํ๋ ๊ฒ์ด ์์ํ ํ์ด๋ฅผ ํ ์ ์๋ค.
๊ทธ ๋ค์์ ์ฝ๋ค. dp ๋ฅผ ์ ์ฉํ์ฌ, ์ด๋ฏธ ๋ฐฉ๋ฌธํ ์์น์ธ ๊ฒฝ์ฐ๋ ๋ํด์ฃผ๋ ๊ฒ์ผ๋ก ์ถ๊ฐ์ ์ธ ์ฐ์ฐ์ ์ค์ผ ์ ์๋ค. ๊ธฐ์ตํ์.
๊ทธ๋ฆฌ๊ณ setrecursionlimit์ ํจ์๋คโฆ
Code
import sys
from pprint import pprint
sys.setrecursionlimit(int(1e6))
input = sys.stdin.readline
n, m = map(int, input().split())
graph = [list(map(int, input().split())) for _ in range(n)]
dp = [[-1 for _ in range(m)] for _ in range(n)]
d = [[1, 0], [0, 1], [-1, 0], [0, -1]]
# dp[i][j] = 4๋ฐฉํฅ์์ ๋ฐ์ํ๋ ๊ฐ๋ฅํ ๊ฒฝ๋ก์ ํฉ(๋จ, graph[i][j] > graph์ ๋ค์ ๊ฒฝ๋ก : ์ฆ, ๊ฐ๋ฅํ ๊ฒฝ๋ก)
def DFS(y, x):
dp[y][x] = 0 # ํด๋น ํจ์์ ํธ์ถ ์ด์ ๋, ํด๋น ์ง์ ์ผ๋ก ๋ถํฐ ๊ฒฝ๋ก๋ฅผ ๊ตฌํ๋ผ๋ ๊ฒ์ : ๊ฒฝ๋ก ๊ฐ์๋ 0๊ฐ์ผ ์ ์์
if y == n - 1 and x == m - 1: # ๊ฒฝ๋ก๋ฅผ ๊ตฌํ๋ผ๊ณ ํ๋๋ฐ ๋์ฐฉ์ง์ ์ด๋ฉด ๊ฒฝ๋ก๋ฅผ 1๋ก ์
๋ฐ์ดํธ ํด์ค
dp[y][x] = 1
return dp[y][x]
for dy, dx in d:
ny, nx = y + dy, x + dx
if 0 <= ny < n and 0 <= nx < m and graph[y][x] > graph[ny][nx]:
if dp[ny][nx] == -1: # ์์ง ๋ฐฉ๋ฌธํ์ง ์์๋ค๋ฉด,
dp[ny][nx] = DFS(ny, nx)
dp[y][x] += dp[ny][nx] # ์ด๋ฏธ ๋ฐฉ๋ฌธํด์ ํ์์ ์๋ฃํ๋ค๋ฉด, ๊ทธ๋๋ก ๋ํด์ค
return dp[y][x]
print(DFS(0, 0))