[BOJ][๐ก4][๋ฐฑ์ค#14722] ์ฐ์ ๋์
์์ฑ:    
์ ๋ฐ์ดํธ:
์นดํ ๊ณ ๋ฆฌ: BOJ Gold IV
๋ฌธ์ ์ถ์ฒ
๋ฌธ์
์ํ์ด๋ ๋ธ๊ธฐ์ฐ์ , ์ด์ฝ์ฐ์ , ๋ฐ๋๋์ฐ์ ๋ฅผ ์ข์ํ๋ค. ์ ๋ง์ด ๋งค์ฐ ๊น๋ค๋ก์ด ์ํ์ด๋ ์์ ๋ง์ ์ฐ์ ๋ฅผ ๋ง์๋ ๊ท์น์ด ์๋ค.ย
๋งจ ์ฒ์์๋ ๋ธ๊ธฐ์ฐ์ ๋ฅผ ํ ํฉ ๋ง์ ๋ค. ๋ธ๊ธฐ์ฐ์ ๋ฅผ ํ ํฉ ๋ง์ ํ์๋ ์ด์ฝ์ฐ์ ๋ฅผ ํ ํฉ ๋ง์ ๋ค. ์ด์ฝ์ฐ์ ๋ฅผ ํ ํฉ ๋ง์ ํ์๋ ๋ฐ๋๋์ฐ์ ๋ฅผ ํ ํฉ ๋ง์ ๋ค. ๋ฐ๋๋์ฐ์ ๋ฅผ ํ ํฉ ๋ง์ ํ์๋ ๋ธ๊ธฐ์ฐ์ ๋ฅผ ํ ํฉ ๋ง์ ๋ค.ย
์ ๋ฒ ์ถ์ ์์ ์๋ง์ ์ฐ์ ๋ฅผ ๋ง์ จ์ง๋ง ๋์ฑ ์ฐ์ ์ ๊ฐ์ฆ์ ๋๋ ์ํ์ด๋ ์ฐ์ ์ฌํ์ ๋ ๋ฌ๋ค. ๋ง์๋ ์ฐ์ ๋ฅผ ์ฐพ์ ๋ ๋ ์ํ์ด๋ ์๋ง์ ์ฐ์ ๊ฐ๊ฒ๋ก ๋๋ฌ ์์ธ ์ด๋ ๋์์ ๋์ฐฉํ๋ค. ์ด ๋์๋ ์ ์ฌ๊ฐํ ํํ์ 2์ฐจ์ ๊ฒฉ์ ๋ชจ์์ผ๋ก ๋จ๋ถ์ผ๋ก N๊ฐ, ๋์๋ก N๊ฐ, ์ด N*N๊ฐ์ ์ฐ์ ๊ฐ๊ฒ๋ค์ด ์๋ค. ์ํ์ด๋ ๋์์ ์๋ถ์ชฝ ๋ (1, 1)์์ ์ถ๋ฐํด์ ๋๋จ์ชฝ ์๋ (N, N)๊น์ง ๊น์ง ๊ฐ๋ฉด์ ์ฐ์ ๋ฅผ ์ฌ ๋ง์ ๋ค.ย ๊ฐ๊ฐ์ ์ฐ์ ๊ฐ๊ฒ๋ ๋ธ๊ธฐ, ์ด์ฝ, ๋ฐ๋๋ ์ค ํ ์ข ๋ฅ์ ์ฐ์ ๋ง์ ์ทจ๊ธํ๋ค. ๊ฐ๊ฐ์ ์ฐ์ ๊ฐ๊ฒ ์์์, ์ํ์ด๋ ์ฐ์ ๋ฅผ ์ฌ ๋ง์๊ฑฐ๋, ์ฌ ๋ง์์ง ์๋๋ค. So cooooool~ํ ์ํ์ด๋ ์ค์ง ๋์ชฝ ๋๋ ๋จ์ชฝ์ผ๋ก๋ง ์์ง์ด๊ธฐ ๋๋ฌธ์ ํ ๋ฒ ์ง๋์น ์ฐ์ ๊ฐ๊ฒ์๋ ๋ค์ ๊ฐ์ง ์๋๋ค. ์ํ์ด๊ฐ ๋ง์ค ์ ์๋ ์ฐ์ ์ ์ต๋ ๊ฐ์๋ฅผ ๊ตฌํ์ฌ๋ผ.
์ ๋ ฅ
์ฒซ ๋ฒ์งธ ์ค์๋ ์ฐ์ ๋์์ ์์ญ ํฌ๊ธฐ N์ด ์ฃผ์ด์ง๋ค. (1 โค N โค 1000) ๋ ๋ฒ์งธ ์ค๋ถํฐ N+1 ๋ฒ์งธ ์ค๊น์ง ์ฐ์ ๋์์ ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋ค. 0์ ๋ธ๊ธฐ์ฐ์ ๋ง์ ํ๋ ๊ฐ๊ฒ, 1์ ์ด์ฝ์ฐ์ ๋ง์ ํ๋ ๊ฐ๊ฒ, 2๋ ๋ฐ๋๋์ฐ์ ๋ง์ ํ๋ ๊ฐ๊ฒ๋ฅผ ๋ปํ๋ฉฐ, 0, 1, 2 ์ธ์ ์ ์๋ ์ฃผ์ด์ง์ง ์๋๋ค.
์ถ๋ ฅ
์ํ์ด๊ฐ ๋ง์ค ์ ์๋ ์ฐ์ ์ ์ต๋ ๊ฐ์๋ฅผ ์ถ๋ ฅํ์์ค.
์์
์์ 1
์ ๋ ฅ
4
0 1 2 2
1 1 1 1
2 2 2 2
0 0 1 0
์ถ๋ ฅ
5
์์ 2
์ ๋ ฅ
5
0 1 0 0 0
1 2 1 1 1
2 0 1 2 0
0 0 0 0 1
1 1 1 1 2
์ถ๋ ฅ
9
My Sol
import sys
input = sys.stdin.readline
N = int(input())
mat = [list(map(int, input().split())) for _ in range(N)]
dp = [[[0, -1] for _ in range(N+1)] for _ in range(N+1)]
for i in range(1, N+1):
for j in range(1, N+1):
left, up = dp[i][j-1], dp[i-1][j]
left_check = (left[1]+1)%3 == mat[i-1][j-1]
up_check = (up[1]+1)%3 == mat[i-1][j-1]
left_score = left[0] + left_check
up_score = up[0] + up_check
if left_score > up_score:
dp[i][j][0] = left_score
dp[i][j][1] = mat[i-1][j-1] if left_check else left[1]
else:
dp[i][j][0] = up_score
dp[i][j][1] = mat[i-1][j-1] if up_check else up[1]
print(dp[N][N][0])
DP๋ฅผ ์ด์ฉํ๋ ๋ฌธ์ ์๋ค. ์กฐ๊ธ ํน์ดํ๋ ์ ์, ๊ธฐ์ค์ด ๋๋ ์์ ์นธ๊ณผ ์ผ์ชฝ ์นธ์ ์ฐ์ ์ ๋ณด ์ค ์ฑํ๋ ๊ฒ์ ์ ์ฅํด์ผ ํ๊ธฐ ๋๋ฌธ์ 3์ฐจ์ ๋ฐฐ์ด์ ์ฌ์ฉํ๋ค.
์ ๊ทผ์ ๋ค์๊ณผ ๊ฐ๋ค.
- dp ๋ฐฐ์ด์ ์ด๊ธฐํํด ๋ง๋ค์ด์ค๋ค.
- dp ์์ชฝ๊ณผ ์ผ์ชฝ์ ์นธ๋ค์์ ๊ฐ๊ฐ ์ฐ์ ์ ๋ณด(๊ฐ ์นธ[1])๋ฅผ ํ์ธํด ์ง๊ธ ์์นํ๋ ์นธ๊ณผ ์ฐ๊ฒฐ์ด ๋๋์ง ํ์ธํ๋ค.
- ์ฐ๊ฒฐ์ด ๋๋ค๋ฉด ๋์ ์ฐ์ (๊ฐ ์นธ[0])์ 1์ ๋ํด์ค๋ค.
- ์ด๋ ๊ฒ ๋์ ์ฌ๋ถ๊น์ง ํ์ธํ ์ผ์ชฝ ์นธ๊ณผ ์์ ์นธ์ ๋์ ์ฐ์ ๋ฅผ ๋น๊ตํด ๋ ํฐ ์ชฝ์ ์ฑํํ๋ค.
- ์ด๋ ์ฑํ๋ ์นธ์ ์ด๋ฏธ ์กด์ฌํ๋ ์ฐ์ ์ ๋ณด์ ํ์ฌ ์นธ์ ์ฐ์ ์ ๋ณด๊ฐ ์ฐ๊ฒฐ๋๋ค๋ฉด ํ์ฌ ์นธ์ ์ฐ์ ์ ๋ณด๋ฅผ, ์๋๋ผ๋ฉด ์ฑํ๋ ์นธ์ ์ฐ์ ์ ๋ณด๋ฅผ ํ์ฌ ์นธ์ ์ฐ์ ์ ๋ณด์ ์ ์ฅํ๋ค.
dp ๋ฐฐ์ด์ (N+1) x (N+1)์ ํฌ๊ธฐ๋ก ์ ์ํ๋ฉฐ, dp(1,1)์์ ์์ชฝ, ์ผ์ชฝ ๊ฐ์ ์กฐํํ๋ฉฐ ์์ํ๊ธฐ ๋๋ฌธ์ range(1, N+1)๋ก ์ํํ๋ค.
๊ตฌ์กฐ๊ฐ ๋ณต์กํด ์ค์ํ๋ ๊ฒ์ ๋ฐฉ์งํ๊ธฐ ์ํด ๋ณ์๋ก ์ ์ฅํด๊ฐ๋ฉฐ ์ถ๊ฐํด ๋ฃ์ด์ฃผ์๋ค.
๊ฒฐ๊ณผ
๋ง์์ต๋๋ค!!
๋ชจ๋ฒ๋ต์
n=int(input())
m=[list(map(int,input().split())) for _ in range(n)]
d=[[0]*(n+1) for _ in range(n+1)]
for i in range(1,n+1):
for j in range(1,n+1):
d[i][j]=max(d[i-1][j],d[i][j-1])
if d[i][j]%3==m[i-1][j-1]:d[i][j]+=1
print(d[-1][-1])
๋ด ํ์ด์ ๋นํด ์ฐ์ฐ์๊ฐ์ 55%, ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ์ 40%, ์ฝ๋ ๊ธธ์ด๋ 30% ์ ๋ ๋๋ ์ฝ๋๊ฐ ์์ด์ ๋ถ์ํด๋ณด๋ ค ํ๋ค.
์ด ๋ถ์ ์ฐ์ ์ ๋ณด๋ฅผ ์ ์ฅํ์ง ์๊ณ 2์ฐจ์ dp ๋ฐฐ์ด์ ๋ง๋ค์ด ์ฌ์ฉํ์ผ๋ฉฐ, ์ฐ์ ์ ๋ณด๋ ํ์ฌ๊น์ง์ ๋์ ์ฐ์ ๋ฅผ 3์ผ๋ก ๋๋ ๋๋จธ์ง์ ๊ฐ์ ๊ฒ์ ์ด์ฉํ๋คโฆ ๋ ์ ์ด ์๊ฐ์ ๋ชป ํ์ง..
์ผ์ชฝ, ์์ชฝ์ dp ๊ฐ ์ค ๋ ํฐ ๊ฐ์ ํ์ฌ ์นธ์ ๋ฃ๊ณ , ์ด๋ฅผ 3์ผ๋ก ๋๋ ๋๋จธ์ง๊ฐ ํ์ฌ ์นธ์ ์ฐ์ ์ ๋ณด์ ๊ฐ๋ค๋ฉด ํ๋ ๋ ๋๋ ค์ฃผ๋ ๋ฐฉ์์ธ ๊ฒ์ด๋ค. ๋๋ํ ํ์ด์๋ค.
๋๊ธ๋จ๊ธฐ๊ธฐ