๐ณ ๋งํฌ
๋ฐฑ์ค 1937๋ฒ ์์ฌ์์ด ํ๋ค
๐ ๋ฌธ์
n*n์ ํฌ๊ธฐ์ ๋๋๋ฌด ์ฒ์ด ์๋ค. ์์ฌ์์ด ํ๋ค๋ ์ด๋ค ์ง์ญ์์ ๋๋๋ฌด๋ฅผ ๋จน๊ธฐ ์์ํ๋ค. ๊ทธ๋ฆฌ๊ณ ๊ทธ ๊ณณ์ ๋๋๋ฌด๋ฅผ ๋ค ๋จน์ด ์น์ฐ๋ฉด ์, ํ, ์ข, ์ฐ ์ค ํ ๊ณณ์ผ๋ก ์ด๋์ ํ๋ค. ๊ทธ๋ฆฌ๊ณ ๋ ๊ทธ๊ณณ์์ ๋๋๋ฌด๋ฅผ ๋จน๋๋ค. ๊ทธ๋ฐ๋ฐ ๋จ ์กฐ๊ฑด์ด ์๋ค. ์ด ํ๋ค๋ ๋งค์ฐ ์์ฌ์ด ๋ง์์ ๋๋๋ฌด๋ฅผ ๋จน๊ณ ์๋ฆฌ๋ฅผ ์ฎ๊ธฐ๋ฉด ๊ทธ ์ฎ๊ธด ์ง์ญ์ ๊ทธ ์ ์ง์ญ๋ณด๋ค ๋๋๋ฌด๊ฐ ๋ง์ด ์์ด์ผ ํ๋ค. ๋ง์ฝ์ ๊ทธ๋ฐ ์ง์ ์ด ์์ผ๋ฉด ์ด ํ๋ค๋ ๋ถ๋ง์ ๊ฐ์ง๊ณ ๋จ์ ํฌ์์ ํ๋ค๊ฐ ์ฃฝ๊ฒ ๋๋ค(-_-)
์ด ํ๋ค์ ์ฌ์ก์ฌ๋ ์ด๋ฐ ํ๋ค๋ฅผ ๋๋๋ฌด ์ฒ์ ํ์ด ๋์์ผ ํ๋๋ฐ, ์ด๋ค ์ง์ ์ ์ฒ์์ ํ์ด ๋์์ผ ํ๊ณ , ์ด๋ค ๊ณณ์ผ๋ก ์ด๋์ ์์ผ์ผ ๋ ๋ค ์์คํ ์๋ช ์ด์ง๋ง ํ๋ค๊ฐ ์ต๋ํ ์ค๋ ์ด ์ ์๋์ง ๊ณ ๋ฏผ์ ๋น ์ ธ ์๋ค. ์ฐ๋ฆฌ์ ์๋ฌด๋ ์ด ์ฌ์ก์ฌ๋ฅผ ๋์์ฃผ๋ ๊ฒ์ด๋ค. n*n ํฌ๊ธฐ์ ๋๋๋ฌด ์ฒ์ด ์ฃผ์ด์ ธ ์์ ๋, ์ด ํ๋ค๊ฐ ์ต๋ํ ์ค๋ ์ด๋ ค๋ฉด ์ด๋ค ๊ฒฝ๋ก๋ฅผ ํตํ์ฌ ์์ง์ฌ์ผ ํ๋์ง ๊ตฌํ์ฌ๋ผ.
๐พ ํ์ด ๋ฐฉ๋ฒ
- ๋จผ์ , ์
๋ ฅ์ ๋ค ๋ฐ๊ณ ๋ ๋ค
check
๋ผ๋ ์ด๋๊ฐ์ ์ ์ฅํด์ค ๋ฆฌ์คํธ๋ฅผ ์ ์ธํ๋ค. ์ดcheck
์๋ ํน์ [i][j] ์นธ๊น์ง์ ์ด๋ ๊ฑฐ๋ฆฌ๋ฅผ ์ ์ฅํ๋ค. - ์ ํ ์ข ์ฐ, ๋ ํฐ ๊ฐ์ผ๋ก ์ด๋ํ๋ฉฐ ์ด์ check๊ฐ๊ณผ ๋น๊ตํ์ฌ update๋ฅผ ํด์ค๋ค.
์ด ๋, ๋จ์ํ +1์ ํ๊ณ dfs๋ฅผ ๊ณ์ ๋๊ฒ ๋๋ฉด ์๊ฐ ์ด๊ณผ๊ฐ ๋ฐ์ํ๋ค. ์ด ๋ฌธ์ ๋ dp์ค๋ฝ๊ฒ ํ์ด์ผํ๋ฏ๋ก, ๋จ์ํ +1์ ํ๋ ๊ฒ์ด ์๋ ํ์ฌ์check
๊ฐ๊ณผ, ๋ฐ๋ ์ธ๋ฑ์ค๋ก dfs ๋๊ณ ๋ ์ดํ์check
๊ฐ ์ค ๋ ํฐ ๊ฐ์ผ๋ก ์ ๋ฐ์ดํธ ํ๋ค.
์ด๋ ์กฐ๊ธ ๋ค๋ฅธ ๊ฐ๋ ์ด๊ธฐ๋ ํ๋ฐ, dp๋ก ํ๊ธฐ ์ํด์๋ dfs๋ฅผ ํ์์ฉ์ด ์๋, ํ์ฌ ์์น์ check ๊ฐ์ ์ฐพ์๊ฐ๋ค๊ณ ์๊ฐํ ์ ์๋ค. check
์ ๊ฐ์ฅ ์๋ง์ ๊ฐ์ด ์ ์ฅ๋ ๋ค ๋ ์ด์ ๊ฐ ์ธ๋ฑ์ค๊ฐ ์๋ค๋ฉด ํด๋นcheck
๊ฐ์ ๋ฆฌํดํ๋ค.check
๋ฐฐ์ด์ ๊ฐ์ฅ ํฐ ๊ฐ์ printํ๋ค.
solution ์ฝ๋
import sys
sys.setrecursionlimit(10 ** 5)
sys.stdin = open("input.txt","rt")
dx = [-1,1,0,0]
dy = [0,0,-1,1]
def dfs(x,y):
if check[x][y]: #์ฒดํฌ๊ฐ 0์ด ์๋ ๊ฒฝ์ฐ (์ด๋ฏธ ๋ค๋
์จ ๊ฒฝ์ฐ)
return check[x][y] #์ฒดํฌ๋ฅผ ๋ฆฌํดํด์ค.
check[x][y] = 1 # ์ฒดํฌ๊ฐ 0์ธ ๊ฒฝ์ฐ์๋ ์ฒดํฌ๋ฅผ 1๋ก ์ด๊ธฐํํด์ค.
for i in range(4):
nx = x + dx[i]
ny = y + dy[i]
# ๋ฒ์์ ์๋ง์ nx,ny์ ๋ํ์ฌ ๋๋๋ฌด๊ฐ์๋ ๋ ๋ง๋ค๋ฉด,
if 0 <= nx < n and 0 <= ny < n and forest[x][y] < forest[nx][ny]:
# ํด๋น ์ฒดํฌ์ ๊ธฐ์กด์ ์ฒดํฌ์, dfs๋ฅผ ๋๊ณ ๋ ๋ค์ ์ฒดํฌ๊ฐ์ +1 ํ ๊ฐ ์ค ๋ ํฐ ๊ฐ์ ์ ์ฅ
# 1์ ๋ํ๋ ์ด์ ๋ ๊ธฐ์กด ๊ฐ์์ ๋ ๋์๊ฐ ๊ฒฝ์ฐ์ด๋ฏ๋ก ํ์นธ์ ์ถ๊ฐํด์ฃผ๋ ๊ฒ๊ณผ ๊ฐ๋ค.
check[x][y] = max(check[x][y], dfs(nx,ny) + 1)
return check[x][y]
n = int(sys.stdin.readline())
forest = []
for _ in range(n):
forest.append(list(map(int,sys.stdin.readline().split())))
check = [[0] * n for _ in range(n)]
for i in range(n):
for j in range(n):
check[i][j] = dfs(i,j) # ์ฒดํฌ ๋ฐฐ์ด์, dfs๋ฅผ ํตํด ์ป์ ํด๋น ์ฒดํฌ์ ๊ฐ์ ์ ์ฅ.
print(max(map(max,check)))
์๊ฐ์ด๊ณผ ์ฝ๋
import sys
sys.setrecursionlimit(10 ** 5)
sys.stdin = open("input.txt","rt")
dx = [-1,1,0,0]
dy = [0,0,-1,1]
def dfs(x,y):
for i in range(4):
nx = x + dx[i]
ny = y + dy[i]
if 0 <= nx < n and 0 <= ny < n and forest[x][y] < forest[nx][ny]:
if check[nx][ny] == 1 or check[x][y] + 1 > check[nx][ny]:
check[nx][ny] = check[x][y] + 1
dfs(nx, ny)
n = int(sys.stdin.readline())
forest = []
for _ in range(n):
forest.append(list(map(int,sys.stdin.readline().split())))
check = [[1] * n for _ in range(n)]
for i in range(n):
for j in range(n):
if check[i][j] == 1:
dfs(i,j)
res = 0
for i in range(n):
comp = max(check[i])
res = comp if res < comp else res
print(res)