ํ์ด
์ฒ์์ผ๋ก ์ฐ์ตํด๋ณธ BFS ๋ฌธ์ ์ด๋ค. ์ฒ์ ์ ํ๋ ์ ํ์ด๋ค๋ณด๋ ๋ค๋ฅธ ์ฝ๋๋ฅผ ๋ง์ด ์ฐธ๊ณ ํ๋ค.
์ฃผ์ด์ง ํ๊ฒฝ์์ ์ต๋จ๊ฑฐ๋ฆฌ ๋ด์ ์๋ ๋ฌผ๊ณ ๊ธฐ๋ฅผ ๋จน์ผ๋ฉด์ ๋ ์ด์ ๋จน์ ๋ฌผ๊ณ ๊ธฐ๊ฐ ์์ด์ง ๋ ๊น์ง ์๊ธฐ ์์ด๋ฅผ ํค์ฐ๋ ๋ฌธ์ ์ด๋ค.
์ต๋จ๊ฑฐ๋ฆฌ๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ์์๋ BFS ๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค๋ ์ ์ ์๊ณ ์์์ง๋ง ์ด๋ค ์์ผ๋ก ์์ํด์ผํ๋์ง ๋ชฐ๋ผ ๋ง์ด ํด๋งธ๋ค.
์ฐ์ ์ ๋ ฅ์ ๋ฐ์ผ๋ฉด์ ์ฒ์ ์๊ธฐ ์์ด์ ์์น๋ฅผ ์ ์ฅํด์ค๋ค.
ํ์ฌ ์๊ธฐ ์์ด์ ํฌ๊ธฐ ๋ฐ ์์น๋ฅผ ๊ณ ๋ คํด์ ์๊ธฐ ์์ด๊ฐ ๋จน์ ์ ์๋ ๊ฐ์ฅ ๊ฐ๊น์ด ๋ฌผ๊ณ ๊ธฐ์ ์์น์ ๊ฑฐ๋ฆฌ๋ฅผ BFS ๋ฅผ ํตํด ๋ฐํํ๋ค.
BFS ๋ฅผ ๋๋ฆฌ๋ฉด์ ์๊ธฐ ์์ด๊ฐ ๋ฐฉ๋ฌธํ ์ ์๋ ์ขํ์ ๋ํ์ฌ ๋ฐฉ๋ฌธ ์ฒ๋ฆฌ ๋ฐ ๊ฑฐ๋ฆฌ๋ฅผ ์ขํ์ ๋ฐ๋ผ ์ ์ฅํด์ค ๋ค, ์๊ธฐ ์์ด๊ฐ ๋จน์ ์ ์๋ ๋ฌผ๊ณ ๊ธฐ๊ฐ ์์ ๊ฒฝ์ฐ edible ๋ฆฌ์คํธ์ ์ขํ์ ๊ฑฐ๋ฆฌ๋ฅผ ์ ์ฅํด์ค๋ค.
์ดํ ๋ชจ๋ ํ์์ด ๋๋๋ฉด edilbe ๋ฆฌ์คํธ๋ฅผ ๊ฑฐ๋ฆฌ, ๋งจ์, ๋งจ์ผ์ชฝ ์์ผ๋ก ์ ๋ ฌํ ๋ค ๊ฐ์ฅ ์ฒซ ๋ฒ์งธ ์์๊ฐ๋ค์ ๋ฐํํด์ค๋ค.
์ดํ ์๊ธฐ ์์ด์ ์์น๋ฅผ ๋ณ๊ฒฝํ๊ณ ๋ฌธ์ ์กฐ๊ฑด์ ๋ฐ๋ผ์ ๋จน์ ๋ฌผ๊ณ ๊ธฐ์ ๊ฐ์๋ฅผ ์ ์ฅํด์ค๋ค.
๋ง์ฝ ์๊ธฐ ์์ด๊ฐ ๋จน์ ๊ฐ์๊ฐ ์๊ธฐ ๋ชธ์ง๊ณผ ๊ฐ์์ง ๊ฒฝ์ฐ ์๊ธฐ ์์ด์ ๋ชธ์ง์ ํค์ด ๋ค ๋ฐ๋ณตํ๋ค.
๋ง์ฝ ๋ ์ด์ ์๊ธฐ ์์ด๊ฐ ๋จน์ ์ ์๋ ๋ฌผ๊ณ ๊ธฐ๊ฐ ํ์์์ ๋ฐ๊ฒฌ๋์ง ์์ ์ -1 ์ ๋ฐํํ๋๋ก ํ๊ณ -1 ์ด ๋ฐํ๋๋ฉด ๋ฐ๋ณต๋ฌธ์ ์ข ๋ฃํ ๋ค ์ด๋ํ ์ด ๊ฑฐ๋ฆฌ๋ฅผ ์ถ๋ ฅํด์ฃผ๋ฉด๋๋ค.
์ด ๋ฌธ์ ๋ฅผ ํตํด ๊ฐ ์ํฉ๋ง๋ค ์ต๋จ๊ฑฐ๋ฆฌ๋ฅผ BFS ๋ก ๋ฐํ๋ฐ๊ณ ๋ ์ด์ ๋ง๋ ์กฐ๊ฑด์ ์ฐพ์ ์ ์์ ๋ ๊น์ง 2์ฐจ์ ๋ฐฐ์ด์ ์์ ํด์ฃผ๋ฉด์ ๋ฐ๋ณต์ ํด์ผํ๋ค๋ ์ ์ ์๊ฒ๋์๋ค.
์์ค์ฝ๋
# ์๊ธฐ ์์ด
from collections import deque
import sys
input = sys.stdin.readline
def bfs(i, j): # i, j ์ขํ์์ ํ์ฌ ์๊ธฐ ์์ด๊ฐ ๋จน์ ์ ์๋ ๋ชจ๋ ๋ฌผ๊ณ ๊ธฐ์ ์์น ๋ฐ ๊ฑฐ๋ฆฌ ์ฐพ๊ณ ๊ฐ์ฅ ๊ฐ๊น์ด ๋ฌผ๊ณ ๊ธฐ์ ์ ๋ณด๋ฅผ ๋ฐํ
visited = [[0] * n for i in range(n)]
visited[i][j] = 1
edible = []
dist = [[0] * n for i in range(n)]
q = deque()
q.append([i, j])
while q:
x, y = q.popleft()
for k in range(4):
nx = x + dx[k]
ny = y + dy[k]
if 0 <= nx < n and 0 <= ny < n and visited[nx][ny] == 0: # ํ๋ฒ๋ ๊ฐ ์ ์ด ์์ผ๋ฉฐ ๋ฒ์ ๋ด์ผ ๋
if s[nx][ny] <= s[i][j] or s[nx][ny] == 0: # ์๊ธฐ๋ณด๋ค ์๊ฑฐ๋ 0 ์ผ ๊ฒฝ์ฐ ์ด๋ ๊ฐ๋ฅ
q.append([nx, ny])
visited[nx][ny] = 1 # ๋ฐฉ๋ฌธ ์ฒ๋ฆฌ
dist[nx][ny] = dist[x][y] + 1
if s[nx][ny] < s[i][j] and s[nx][ny] != 0: # ๋จน์ ์ ์๋ ๋ฌผ๊ณ ๊ธฐ์ผ ๊ฒฝ์ฐ
edible.append([nx, ny, dist[nx][ny]]) # ๊ทธ ๋ฌผ๊ณ ๊ธฐ์ ์ขํ ๋ฐ ๊ฑฐ๋ฆฌ๋ฅผ ์ ์ฅ
if not edible: # ๋จน์ ์ ์๋ ๋ฌผ๊ณ ๊ธฐ๊ฐ ์์ ๊ฒฝ์ฐ
return -1, -1, -1
edible.sort(key=lambda x: (x[2], x[0], x[1])) # ๊ฑฐ๋ฆฌ, ๋งจ์, ๋งจ์ผ์ชฝ ์์ผ๋ก ์ ๋ ฌ
return edible[0][0], edible[0][1], edible[0][2]
dx = [1, -1, 0, 0]
dy = [0, 0, -1, 1]
n = int(input())
s = []
for i in range(n):
a = list(map(int, input().split()))
s.append(a)
for j in range(n):
if a[j] == 9: # ์๊ธฐ ์์ด ์์น ํ์ธ
s[i][j] = 2
start = [i, j]
exp = 0
cnt = 0
while True:
i, j = start[0], start[1]
ex, ey, dist = bfs(i, j)
if ex == -1: break
s[ex][ey] = s[i][j] # ์๊ธฐ ์์ด๊ฐ bfs ๋ฅผ ํตํด ์ฐพ์ ๊ฐ์ฅ ๊ฐ๊น์ด ๋จน์ด๋ฅผ ๋จน๊ณ ๋ ํ์ ์์น
s[i][j] = 0
start = [ex, ey] # ์๋ก์ด ์์ ์์น ์ค์
exp += 1 # ํ ๋ง๋ฆฌ ๋จน์๋ค๋ ์ ๋ณด๋ฅผ ์ ์ฅ
if exp == s[ex][ey]: # ์์ ์ ํฌ๊ธฐ์ ๊ฐ์ ์ซ์์ ๋ฌผ๊ณ ๋ฆฌ๋ฅผ ๋จน์์ ๋
s[ex][ey] += 1 # ํฌ๊ธฐ๊ฐ 1๋งํผ ์ปค์ง
exp = 0 # ์ด๊ธฐํ
cnt += dist
print(cnt)