๐ ๋ฌธ์
https://programmers.co.kr/learn/courses/30/lessons/42898
๋ฌธ์ ์ค๋ช
๊ณ์๋๋ ํญ์ฐ๋ก ์ผ๋ถ ์ง์ญ์ด ๋ฌผ์ ์ ๊ฒผ์ต๋๋ค. ๋ฌผ์ ์ ๊ธฐ์ง ์์ ์ง์ญ์ ํตํด ํ๊ต๋ฅผ ๊ฐ๋ ค๊ณ ํฉ๋๋ค. ์ง์์ ํ๊ต๊น์ง ๊ฐ๋ ๊ธธ์ m x n ํฌ๊ธฐ์ ๊ฒฉ์๋ชจ์์ผ๋ก ๋ํ๋ผ ์ ์์ต๋๋ค.
์๋ ๊ทธ๋ฆผ์ m = 4, n = 3 ์ธ ๊ฒฝ์ฐ์ ๋๋ค.
๊ฐ์ฅ ์ผ์ชฝ ์, ์ฆ ์ง์ด ์๋ ๊ณณ์ ์ขํ๋ (1, 1)๋ก ๋ํ๋ด๊ณ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ์๋, ์ฆ ํ๊ต๊ฐ ์๋ ๊ณณ์ ์ขํ๋ (m, n)์ผ๋ก ๋ํ๋ ๋๋ค.
๊ฒฉ์์ ํฌ๊ธฐ m, n๊ณผ ๋ฌผ์ด ์ ๊ธด ์ง์ญ์ ์ขํ๋ฅผ ๋ด์ 2์ฐจ์ ๋ฐฐ์ด puddles์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ์ค๋ฅธ์ชฝ๊ณผ ์๋์ชฝ์ผ๋ก๋ง ์์ง์ฌ ์ง์์ ํ๊ต๊น์ง ๊ฐ ์ ์๋ ์ต๋จ๊ฒฝ๋ก์ ๊ฐ์๋ฅผ 1,000,000,007๋ก ๋๋ ๋๋จธ์ง๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- ๊ฒฉ์์ ํฌ๊ธฐ m, n์ 1 ์ด์ 100 ์ดํ์ธ ์์ฐ์์
๋๋ค.
- m๊ณผ n์ด ๋ชจ๋ 1์ธ ๊ฒฝ์ฐ๋ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง์ง ์์ต๋๋ค.
- ๋ฌผ์ ์ ๊ธด ์ง์ญ์ 0๊ฐ ์ด์ 10๊ฐ ์ดํ์ ๋๋ค.
- ์ง๊ณผ ํ๊ต๊ฐ ๋ฌผ์ ์ ๊ธด ๊ฒฝ์ฐ๋ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง์ง ์์ต๋๋ค.
์ ์ถ๋ ฅ ์
m/ n/ puddles/ return
4 | 3 | [[2, 2]] | 4 |
์ ์ถ๋ ฅ ์ ์ค๋ช
โ๏ธ ํ์ด
๐ก ์ข์๋จ->์ฐํ๋จ์ ์ต๋จ๊ฒฝ๋ก ํ๋ฆ์์, ํน์ ์์น๋ก ๊ฐ๋ ๊ฒฝ๋ก์ ์๋ ์ผ์ชฝ ์์น๊ฐ ๊ฐ์ง ๊ฒฝ๋ก์ ์ + ์์ชฝ ์์น๊ฐ ๊ฐ์ง ๊ฒฝ๋ก์ ์์ด๋ค. ๊ฐ์์ ๊ฒฝ์ฐ์์ โก๏ธ/ โฌ๏ธ ์ผ์ด์ค๋ง ์ถ๊ฐํด์ฃผ๋ฉด ๋๊ธฐ ๋๋ฌธ์ด๋ค.
โ๏ธ ๊ตฌํ๊ณ ์ ํ๋ ์์น๋ก ๊ฐ๋ ์ต๋จ๊ฒฝ๋ก์ ์๋ฅผ ํธ์ถํ๋ค.
โ๏ธ ๊ตฌํ๊ณ ์ ํ๋ ์์น๊ฐ ๋ฌผ์ ๋ฉ์ด ์์น๊ฑฐ๋, ๋ฒ์๋ฅผ ๋ฒ์ด๋ ๊ณณ์ด๋ฉด ๊ฒฝ๋ก๊ฐ ์๋ค๋ ์๋ฏธ๋ก 0์ ๋ฆฌํดํ๋ค.
โ๏ธ ๊ฐ ์ ์๋ ์์น์ด๊ณ , ์ด์ ๋ํ ์ต๋จ๊ฒฝ๋ก ์๊ฐ ์ ์ฅ๋์ด ์์ผ๋ฉด ์ด๋ฅผ ๋ฆฌํดํ๋ค.
โ๏ธ ๊ฐ์ด ์ ์ฅ๋์ด ์์ง ์์ผ๋ฉด ์ผ์ชฝ ์์น๊ฐ ๊ฐ์ง ์ต๋จ ๊ฒฝ๋ก์ ์, ์์ชฝ ์์น๊ฐ ๊ฐ์ง ์ต๋จ ๊ฒฝ๋ก์ ์๋ฅผ ํธ์ถํ๋ค. ์ด๋ฅผ ๋ํ ๊ฐ์ ์ ์ฅํ๊ณ ๋ฆฌํดํ๋ค.
๐โ๏ธ ์๊ฒฌ
DP ์ด๋ ต๋ค...................
๋ฉ๋ชจ์ด์ ์ด์ (Memoization)์ผ๋ก ํธ๋ ์ ์ ์ฝ๋์ด๋ ์ด๊ฒ๋ ์ฝ๋ ํ๋ฆ์ ์๊ธฐํด๋๋ ๊ฒ์ด ์ข์ ๊ฒ ๊ฐ๋ค.
๐ป ์์ค์ฝ๋: ํ์ด์ฌ(Python)
def solution(m, n, puddles):
div = 1000000007
dp = [[0 for _ in range(m+1)] for _ in range(n+1)]
for pd in puddles:
dp[pd[0]][pd[1]] = -1
dp[1][1] = 1
def routes(n, m):
if dp[n][m] > 0:
return dp[n][m]
if n < 1 or m < 1 or dp[n][m] == -1:
return 0
dp[n][m] = routes(n-1, m)+routes(n, m-1)
return dp[n][m]
return routes(n, m) % div
m = 4
n = 3
puddles = [[2, 2]]
print(solution(m, n, puddles))
๐ ๐ ๐
๏ผฐ๏ฝ๏ฝ๏ฝ๏ฝ ๏ฝ ๏ผข๏ฝ ๏ผณ๏ผก๏ผน
๐๐ฉ๐ข๐ฏ๐ฌ๐ด ๐ง๐ฐ๐ณ ๐ณ๐ฆ๐ข๐ฅ๐ช๐ฏ๐จ