์ฒ ์์ ํ ๋งํ ๋์ฅ์์๋ ํ ๋งํ ๋ฅผ ๋ณด๊ดํ๋ ํฐ ์ฐฝ๊ณ ๋ฅผ ๊ฐ์ง๊ณ ์๋ค. ํ ๋งํ ๋ ์๋์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ๊ฒฉ์ ๋ชจ์ ์์์ ์นธ์ ํ๋์ฉ ๋ฃ์ด์ ์ฐฝ๊ณ ์ ๋ณด๊ดํ๋ค.
์ฐฝ๊ณ ์ ๋ณด๊ด๋๋ ํ ๋งํ ๋ค ์ค์๋ ์ ์ต์ ๊ฒ๋ ์์ง๋ง, ์์ง ์ต์ง ์์ ํ ๋งํ ๋ค๋ ์์ ์ ์๋ค.
๋ณด๊ด ํ ํ๋ฃจ๊ฐ ์ง๋๋ฉด, ์ต์ ํ ๋งํ ๋ค์ ์ธ์ ํ ๊ณณ์ ์๋ ์ต์ง ์์ ํ ๋งํ ๋ค์ ์ต์ ํ ๋งํ ์ ์ํฅ์ ๋ฐ์ ์ต๊ฒ ๋๋ค. ํ๋์ ํ ๋งํ ์ ์ธ์ ํ ๊ณณ์ ์ผ์ชฝ, ์ค๋ฅธ์ชฝ, ์, ๋ค ๋ค ๋ฐฉํฅ์ ์๋ ํ ๋งํ ๋ฅผ ์๋ฏธํ๋ค. ๋๊ฐ์ ๋ฐฉํฅ์ ์๋ ํ ๋งํ ๋ค์๊ฒ๋ ์ํฅ์ ์ฃผ์ง ๋ชปํ๋ฉฐ, ํ ๋งํ ๊ฐ ํผ์ ์ ์ ๋ก ์ต๋ ๊ฒฝ์ฐ๋ ์๋ค๊ณ ๊ฐ์ ํ๋ค.
์ฒ ์๋ ์ฐฝ๊ณ ์ ๋ณด๊ด๋ ํ ๋งํ ๋ค์ด ๋ฉฐ์น ์ด ์ง๋๋ฉด ๋ค ์ต๊ฒ ๋๋์ง, ๊ทธ ์ต์ ์ผ์๋ฅผ ์๊ณ ์ถ์ด ํ๋ค.
ํ ๋งํ ๋ฅผ ์ฐฝ๊ณ ์ ๋ณด๊ดํ๋ ๊ฒฉ์๋ชจ์์ ์์๋ค์ ํฌ๊ธฐ์ ์ต์ ํ ๋งํ ๋ค๊ณผ ์ต์ง ์์ ํ ๋งํ ๋ค์ ์ ๋ณด๊ฐ ์ฃผ์ด์ก์ ๋, ๋ฉฐ์น ์ด ์ง๋๋ฉด ํ ๋งํ ๋ค์ด ๋ชจ๋ ์ต๋์ง, ๊ทธ ์ต์ ์ผ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋ผ. ๋จ, ์์์ ์ผ๋ถ ์นธ์๋ ํ ๋งํ ๊ฐ ๋ค์ด์์ง ์์ ์๋ ์๋ค.
์ ๋ ฅ
์ฒซ ์ค์๋ ์์์ ํฌ๊ธฐ๋ฅผ ๋ํ๋ด๋ ๋ ์ ์ M,N์ด ์ฃผ์ด์ง๋ค. M์ ์์์ ๊ฐ๋ก ์นธ์ ์, N์ ์์์ ์ธ๋ก ์นธ์ ์๋ฅผ ๋ํ๋ธ๋ค. ๋จ, 2 ≤ M,N ≤ 1,000 ์ด๋ค. ๋์งธ ์ค๋ถํฐ๋ ํ๋์ ์์์ ์ ์ฅ๋ ํ ๋งํ ๋ค์ ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋ค. ์ฆ, ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์๋ ์์์ ๋ด๊ธด ํ ๋งํ ์ ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋ค. ํ๋์ ์ค์๋ ์์ ๊ฐ๋ก์ค์ ๋ค์ด์๋ ํ ๋งํ ์ ์ํ๊ฐ M๊ฐ์ ์ ์๋ก ์ฃผ์ด์ง๋ค. ์ ์ 1์ ์ต์ ํ ๋งํ , ์ ์ 0์ ์ต์ง ์์ ํ ๋งํ , ์ ์ -1์ ํ ๋งํ ๊ฐ ๋ค์ด์์ง ์์ ์นธ์ ๋ํ๋ธ๋ค.
ํ ๋งํ ๊ฐ ํ๋ ์ด์ ์๋ ๊ฒฝ์ฐ๋ง ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ฌ๋ฌ๋ถ์ ํ ๋งํ ๊ฐ ๋ชจ๋ ์ต์ ๋๊น์ง์ ์ต์ ๋ ์ง๋ฅผ ์ถ๋ ฅํด์ผ ํ๋ค. ๋ง์ฝ, ์ ์ฅ๋ ๋๋ถํฐ ๋ชจ๋ ํ ๋งํ ๊ฐ ์ต์ด์๋ ์ํ์ด๋ฉด 0์ ์ถ๋ ฅํด์ผ ํ๊ณ , ํ ๋งํ ๊ฐ ๋ชจ๋ ์ต์ง๋ ๋ชปํ๋ ์ํฉ์ด๋ฉด -1์ ์ถ๋ ฅํด์ผ ํ๋ค.
๐ง ํ์ด
์์ ๋ฌธ์ ๋ ๊ทธ๋ํ ๋ฌธ์ ์ด๋ค.
M์ ๊ฐ๋ก, N์ ์ธ๋ก์ธ ๊ทธ๋ํ๋ฅผ ๋จผ์ ๋ง๋ค์ด์ค๋ค.
๋ฌธ์ ์์ ๋์จ ๊ฒ์ฒ๋ผ ์์์ ์ผ๋ถ ์นธ์๋ ํ ๋งํ ๊ฐ ๋ค์ด์์ง ์์ ์๋ ์์ผ๋ฏ๋ก ํ ๋งํ ๊ฐ ์๋์ง ํ์ธํด์ผ ํ๋ค.
graph[i][j]๊ฐ 0์ผ ๊ฒฝ์ฐ๋ฉด ํ ๋งํ ๊ฐ ์์ง๋ง ์ต์ง ์์ ๊ฒฝ์ฐ, 1์ด๋ฉด ํ ๋งํ ๊ฐ ์๊ณ ์ต์ ๊ฒฝ์ฐ, -1์ด๋ฉด ์์ ์๋ ๊ฒฝ์ฐ์ด๋ค.
์ํ์ข์ฐ๋ก ์ต์ ์ ์์ผ๋ ๋จผ์ 1์ธ ๊ฒฝ์ฐ๋ฅผ ์ฐพ์ ํด๋น ์์น๋ฅผ queue์ ์ ์ฅํ๊ณ dx์ dy๋ฅผ ์ฌ์ฉํ์ฌ ๋๋จธ์ง ํ ๋งํ ๋ฅผ ์ตํ๋ฉด ๋๋ค.
from collections import deque
M, N = map(int, input().split())
graph = []
for i in range(N) :
a = list(map(int, input().split()))
graph.append(a)
# ์ํ์ข์ฐ ํ์์ ์ํจ
dx = [-1, 1, 0, 0]
dy = [0, 0, -1, 1]
queue = deque([])
for i in range(N) :
for j in range(M) :
if graph[i][j] == 1 : #์์์ ํ ๋งํ ๊ฐ ์๊ณ , ์ต์ ๊ฒฝ์ฐ -> 1 -> queue์ ์์น ์ ์ฅ
queue.append([i, j])
res = 0
def bfs() :
while queue :
x, y = queue.popleft()
for i in range(4) :
nx = x + dx[i]
ny = y + dy[i]
if 0<=nx<N and 0<=ny<M and graph[nx][ny] == 0 :
queue.append([nx, ny])
graph[nx][ny] = graph[x][y] + 1 #ํ ๋งํ ๋ฅผ ์ตํ๋ฉด์ ํ์๋ฅผ ์ธ์ค๋ค.
bfs()
#์์ ์์ ํ ๋งํ ๊ฐ ์ ๋ถ ๋ค ์ต์๋์ง ํ์ธํ๊ธฐ
for i in graph :
for j in i :
if j == 0 : #์ ์ต์ ํ ๋งํ ๊ฐ ์๋ค๋ฉด
print(-1) #-1 ์ถ๋ ฅ
exit(0)
res = max(res, max(i)) #์ต๋ ํ์ ๊ณ์ฐ
print(res - 1) #์ฒ์ ์์์ 1๋ก ํํํ์ผ๋ -1์ ํด์ค๋ค.