๐ฉ๐ปโ๐ป๋ฌธ์ ์ค๋ช
[๋ฐฑ์ค 18405] ๊ฒฝ์์ ์ ์ผ (Python)
๋ฌธ์ ์์ฝ
NxN ํฌ๊ธฐ์ ์ํ๊ด์ด ์๋ค. ๋ชจ๋ ๋ฐ์ด๋ฌ์ค๋ 1๋ฒ๋ถํฐ K๋ฒ๊น์ง ์ค ํ๋๋ค.
๋ชจ๋ ๋ฐ์ด๋ฌ์ค๋ 1์ด๋ง๋ค ์, ํ, ์ข, ์ฐ์ ๋ฐฉํฅ์ผ๋ก ์ฆ์ํ๋ค.
๋จ, ๋งค ์ด๋ง๋ค ๋ฒํธ๊ฐ ๋ฎ์ ์ข
๋ฅ์ ๋ฐ์ด๋ฌ์ค๋ถํฐ ๋จผ์ ์ฆ์ํ๋ค. ๋ํ ๋น์นธ์ผ๋ก๋ง ์ฆ์ํ ์ ์๋ค.
S์ด๊ฐ ์ง๋ ํ์ (X,Y)์ ์กด์ฌํ๋ ๋ฐ์ด๋ฌ์ค์ ์ข
๋ฅ๋ฅผ ์ถ๋ ฅํ์์ค.
๋จ, S์ด ํ ๋ฐ์ด๋ฌ์ค๊ฐ ์กด์ฌํ์ง ์๋๋ค๋ฉด, 0์ ์ถ๋ ฅํ๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์์ฐ์ N, K๊ฐ ๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ๊ตฌ๋ถ๋์ด ์ฃผ์ด์ง๋ค. (1 โค N โค 200, 1 โค K โค 1,000)
๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ ๊ฑธ์ณ์ ์ํ๊ด์ ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋ค. ๊ฐ ํ์ N๊ฐ์ ์์๋ก ๊ตฌ์ฑ๋๋ฉฐ, ํด๋น ์์น์ ์กด์ฌํ๋ ๋ฐ์ด๋ฌ์ค์ ๋ฒํธ๊ฐ ๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ๊ตฌ๋ถ๋์ด ์ฃผ์ด์ง๋ค. ๋จ, ํด๋น ์์น์ ๋ฐ์ด๋ฌ์ค๊ฐ ์กด์ฌํ์ง ์๋ ๊ฒฝ์ฐ 0์ด ์ฃผ์ด์ง๋ค.
๋ํ ๋ชจ๋ ๋ฐ์ด๋ฌ์ค์ ๋ฒํธ๋ K์ดํ์ ์์ฐ์๋ก๋ง ์ฃผ์ด์ง๋ค. N+2๋ฒ์งธ ์ค์๋ S, X, Y๊ฐ ๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ๊ตฌ๋ถ๋์ด ์ฃผ์ด์ง๋ค. (0 โค S โค 10,000, 1 โค X, Y โค N)
์ถ๋ ฅ
S์ด ๋ค์ (X,Y)์ ์กด์ฌํ๋ ๋ฐ์ด๋ฌ์ค์ ์ข ๋ฅ๋ฅผ ์ถ๋ ฅํ๋ค. ๋ง์ฝ S์ด ๋ค์ ํด๋น ์์น์ ๋ฐ์ด๋ฌ์ค๊ฐ ์กด์ฌํ์ง ์๋๋ค๋ฉด, 0์ ์ถ๋ ฅํ๋ค.
์์ ์
๋ ฅ 1
3 3
1 0 2
0 0 0
3 0 0
2 3 2
์์ ์ถ๋ ฅ 1
3
์์ ์
๋ ฅ 2
3 3
1 0 2
0 0 0
3 0 0
1 2 2
์์ ์ถ๋ ฅ 2
0
โ๏ธIdea Sketch
์๊ณ ๋ฆฌ์ฆ : BFS
๋ฐ์ด๋ฌ์ค๋ 1์ด๋ง๋ค ์, ํ, ์ข, ์ฐ์ ๋ฐฉํฅ์ผ๋ก ํ ๋จ๊ณ์ฉ ์ฆ์ํ๋ค. ์ฌ๊ธฐ์ BFS ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ์์ ์ ์ ์๋ค.
์๊ฐ๋ณต์ก๋
๊ทธ๋ํ ํฌ๊ธฐ O(NM)
2์ฐจ์ ๋งต์์ ์ํ์ข์ฐ 4๋ฐฉํฅ์ผ๋ก ์์ง์ผ ์ ์์ ๋, BFS ํ์ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ ๊ฒฝ์ฐ ์๊ฐ๋ณต์ก๋๋ ๊ทธ๋ํ ํฌ๊ธฐ O(NM)์ด๋ค.
์ด ๋ฌธ์ ์์๋ ๋ฐ์ด๋ฌ์ค๋ ๋น์นธ์ผ๋ก๋ง ์ฆ์ํ๊ธฐ ๋๋ฌธ์, ์ํ์ข์ฐ ํ์์ ๋๋ธ ์ํ๊ด์ ๋ค์ ๋ฐฉ๋ฌธํ ํ์๊ฐ ์๋ค. ๋ฐ๋ผ์ ์๊ฐ๋ณต์ก๋๋ O(NM)์ด๋ค.
โ๏ธ๋ด ์์ค์ฝ๋
- ๋งค ์ด๋ง๋ค ๋ฒํธ๊ฐ ๋ฎ์ ์ข ๋ฅ์ ๋ฐ์ด๋ฌ์ค๋ถํฐ ๋จผ์ ์ฆ์ํ๋ฏ๋ก heap์ ์ฌ์ฉํ์๋ค.
- ์๋กญ๊ฒ ๋ฐ์ด๋ฌ์ค๊ฐ ์ฆ์ํ ์ํ๊ด์ "1์ด๊ฐ ์ง๋ ๋ค์" ๋ฐฉ๋ฌธํด์ผํ๋ค. ์ฆ ํ์ ์ค์ธ queue๊ฐ ์๋๋ผ new queue์ ์ ๋ณด๋ฅผ ์ ์ฅํด์ผ ํ๋ค.
- 1์ด๊ฐ ์ง๋๋ฉด ์๋กญ๊ฒ ๋ฐ์ด๋ฌ์ค๊ฐ ์ฆ์ํ ์ํ๊ด์ ๋ฐฉ๋ฌธํ๋ค. ๋ฐ๋ผ์ queue๋ new queue๊ฐ ๋๊ณ , new queue๋ ๋น ๋ฐฐ์ด๋ก ์ด๊ธฐํํ๋ค.
- S์ด๊ฐ ์ง๋ ๋ค ์ต์ข target ์ง์ ๋ฐ์ด๋ฌ์ค๋ฅผ ์ถ๋ ฅํ๋ค.
import sys
from copy import deepcopy
from heapq import heappop, heappush
si = sys.stdin.readline
n, k = map(int, si().split())
graph = [list(map(int, si().split())) for _ in range(n)]
s, tx, ty = map(int, si().split())
q, nq = [], []
for i in range(n):
for j in range(n):
if graph[i][j]:
heappush(q, (graph[i][j], i, j))
for _ in range(s):
while q:
v, x, y = heappop(q)
# ๋น ์๋ฆฌ๊ฐ ์๋ ๊ฒฝ์ฐ -> graph ๋ฐ new queue์ ์ถ๊ฐ
for dx, dy in (1, 0), (0, 1), (-1, 0), (0, -1):
nx, ny = x + dx, y + dy
if (0 <= nx < n) and (0 <= ny < n) and graph[nx][ny] == 0:
graph[nx][ny] = v
heappush(nq, (v, nx, ny))
q = deepcopy(nq)
nq = []
print(graph[tx-1][ty-1])