๐น ๋ฑ๊ตฃ๊ธธ
1. ๋ฌธ์ ๋งํฌ
2. ์ฝ๋
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
def solution(m, n, puddles):
answer = 0
dp = [[0] * (m+1) for _ in range(n+1)]
# dp ํ
์ด๋ธ ์ธํ
# puddle ํ์
for y, x in puddles:
dp[x][y] = -1
# ์ธ๋ก ์ธํ
for i in range(1, n+1):
# ์
๋ฉ์ด ์ดํ๋ ์ต๋จ ๊ฑฐ๋ฆฌ ๊ฐ๋๊ธธ ์์
if dp[i][1] == -1:
break
dp[i][1] = 1
# ๊ฐ๋ก ์ธํ
for i in range(1, m+1):
# ์
๋ฉ์ด ์ดํ๋ ์ต๋จ ๊ฑฐ๋ฆฌ ๊ฐ๋๊ธธ ์์
if dp[1][i] == -1:
break
dp[1][i] = 1
# ์ต๋จ ๊ฑฐ๋ฆฌ ๊ฐ์ ํ์
for i in range(2, n+1):
for j in range(2, m+1):
# ํ์ฌ ์์น๊ฐ puddle์ธ ๊ฒฝ์ฐ ํจ์ค
if dp[i][j] == -1:
continue
# ์์ชฝ ๋ชจ๋ puddle ์๋ ๊ฒฝ์ฐ
if dp[i-1][j] != -1 and dp[i][j-1] != -1:
dp[i][j] = dp[i-1][j] + dp[i][j-1]
# ์์ชฝ ๋ชจ๋ puddle์ธ ๊ฒฝ์ฐ
elif dp[i-1][j] == -1 and dp[i][j-1] == -1:
dp[i][j] = 0
# ๋ ์ค ํ๋๋ง puddle์ธ ๊ฒฝ์ฐ
else:
# ๋ ์ค puddle ์๋ ๊ฐ์ ์ ํ
dp[i][j] = max(dp[i-1][j], dp[i][j-1])
return dp[n][m] % 1000000007
์ ํ์ฑ
ํ ์คํธ 1 ใ ํต๊ณผ (0.01ms, 10.2MB) ํ ์คํธ 2 ใ ํต๊ณผ (0.02ms, 10.3MB) ํ ์คํธ 3 ใ ํต๊ณผ (0.02ms, 10.1MB) ํ ์คํธ 4 ใ ํต๊ณผ (0.03ms, 10.2MB) ํ ์คํธ 5 ใ ํต๊ณผ (0.06ms, 10.5MB) ํ ์คํธ 6 ใ ํต๊ณผ (0.06ms, 10.1MB) ํ ์คํธ 7 ใ ํต๊ณผ (0.08ms, 10.3MB) ํ ์คํธ 8 ใ ํต๊ณผ (0.09ms, 10.2MB) ํ ์คํธ 9 ใ ํต๊ณผ (0.05ms, 10.4MB) ํ ์คํธ 10 ใ ํต๊ณผ (0.02ms, 10.3MB) ํจ์จ์ฑ
ํ ์คํธ 1 ใ ํต๊ณผ (2.60ms, 10.3MB) ํ ์คํธ 2 ใ ํต๊ณผ (0.97ms, 10.4MB) ํ ์คํธ 3 ใ ํต๊ณผ (1.54ms, 10.2MB) ํ ์คํธ 4 ใ ํต๊ณผ (3.11ms, 10.3MB) ํ ์คํธ 5 ใ ํต๊ณผ (1.68ms, 10.2MB) ํ ์คํธ 6 ใ ํต๊ณผ (3.02ms, 10.2MB) ํ ์คํธ 7 ใ ํต๊ณผ (1.41ms, 10.2MB) ํ ์คํธ 8 ใ ํต๊ณผ (2.50ms, 10.3MB) ํ ์คํธ 9 ใ ํต๊ณผ (2.67ms, 10.2MB) ํ ์คํธ 10 ใ ํต๊ณผ (1.86ms, 10.2MB)
3. ํด์ค
์คํ๊ต ์ํ๋ ๋ฐฐ์ ๋ ๊ฒฝ์ฐ์ ์ ์ต๋จ ๊ฑฐ๋ฆฌ ๊ฐ์ ๊ตฌํ๊ธฐ๋ฅผ ์ฌ์ฉํ๋ค.
์ ๊ทธ๋ฆผ์์ ์ง๊ณผ ํ๊ต๋ฅผ ๊ผญ์ง์ ์ผ๋ก ๋ณ๊ฒฝํ์ฌ ๋ค์ ๊ทธ๋ฆฌ๋ฉด
๋ค์๊ณผ ๊ฐ์ด ์ต๋จ๊ฑฐ๋ฆฌ์ ๊ฐ์๊ฐ 10์ด ๋์จ๋ค.
์ด๊ฒ์ ํ์ฌ ์์น์์ ๊ฐ๊ฐ โ์์ชฝ ์์นโ์ โ์ผ์ชฝ ์์นโ๊น์ง์ ์ต๋จ ๊ฑฐ๋ฆฌ์ ํฉ์ ์ด์ฉํ ๊ฒ์ด๋ค.
๊ทธ๋ ๋ค๋ฉด dp[i][j] = dp[i-1][j] + dp[i][j-1]์ด ์ฑ๋ฆฝํ๋ค.
๋ง์ฝ ๋ฌผ์ ๋ฉ์ด๋ฅผ ๋ง์ฃผ์น๊ฒ ๋๋ค๋ฉด ๋ค์๊ณผ ๊ฐ์ ๊ฒฝ์ฐ๊ฐ ์๋ค.
์, ์ผ์ชฝ ๋ชจ๋ ๋ฌผ์ ๋ฉ์ด์ธ ๊ฒฝ์ฐ
ํ์ฌ ์์น๋ ๊ฐ ์ ์๋ ์์น๋ก ๊ฐ์ฃผํ์ฌ โ
dp[i][j] = 0
์, ์ผ์ชฝ ๋ ์ค ํ๋๊ฐ ๋ฌผ ์ ๋ฉ์ด์ธ ๊ฒฝ์ฐ
๋ฌผ ์ ๋ฉ์ด์ ์ต๋จ๊ฑฐ๋ฆฌ๋ 0์ผ๋ก ๊ฐ์ฃผํ์ฌ ๋ฌผ ์ ๋ฉ์ด๊ฐ ์๋ ์์น์ ์ต๋จ ๊ฑฐ๋ฆฌ ๊ฐ์์ ๋์ผํด์ง๋ค.
โ
dp[i][j] = max(dp[i-1][j], dp[i][j-1])
(์ด๋, ๋ฌผ์ ๋ฉ์ด ์์น์ dp๊ฐ์ ์ด๋ฏธ -1๋ก ์ด๊ธฐํ ํด๋์์ผ๋ฏ๋ก max๊ฐ์ผ๋ก๋ ๋ฌผ ์ ๋ฉ์ด๊ฐ ์๋ ์์น์ dp๊ฐ์ด ๋ฆฌํด๋๋ค)
๋ฐ๋ผ์ ์ ๊ฒฝ์ฐ๋ฅผ ๋ง์กฑ์ํค๋๋ก dp ๋ฐฐ์ด์ ์ด๊ธฐํ์ํค๊ณ dp[n][m]
์ ๋ฆฌํดํด์ค๋ค.