์ผ์ฑ SW ์ญ๋ ํ ์คํธ ๊ธฐ์ถ ๋ฌธ์ - 16234๋ฒ ์ธ๊ตฌ ์ด๋
๋ฌธ์
N×Nํฌ๊ธฐ์ ๋ ์ด ์๊ณ , ๋ ์ 1×1๊ฐ์ ์นธ์ผ๋ก ๋๋์ด์ ธ ์๋ค. ๊ฐ๊ฐ์ ๋ ์๋ ๋๋ผ๊ฐ ํ๋์ฉ ์กด์ฌํ๋ฉฐ, rํ c์ด์ ์๋ ๋๋ผ์๋ A[r][c]๋ช ์ด ์ด๊ณ ์๋ค. ์ธ์ ํ ๋๋ผ ์ฌ์ด์๋ ๊ตญ๊ฒฝ์ ์ด ์กด์ฌํ๋ค. ๋ชจ๋ ๋๋ผ๋ 1×1 ํฌ๊ธฐ์ด๊ธฐ ๋๋ฌธ์, ๋ชจ๋ ๊ตญ๊ฒฝ์ ์ ์ ์ฌ๊ฐํ ํํ์ด๋ค.
์ค๋๋ถํฐ ์ธ๊ตฌ ์ด๋์ด ์์๋๋ ๋ ์ด๋ค.
์ธ๊ตฌ ์ด๋์ ํ๋ฃจ ๋์ ๋ค์๊ณผ ๊ฐ์ด ์งํ๋๊ณ , ๋ ์ด์ ์๋ ๋ฐฉ๋ฒ์ ์ํด ์ธ๊ตฌ ์ด๋์ด ์์ ๋๊น์ง ์ง์๋๋ค.
- ๊ตญ๊ฒฝ์ ์ ๊ณต์ ํ๋ ๋ ๋๋ผ์ ์ธ๊ตฌ ์ฐจ์ด๊ฐ L๋ช ์ด์, R๋ช ์ดํ๋ผ๋ฉด, ๋ ๋๋ผ๊ฐ ๊ณต์ ํ๋ ๊ตญ๊ฒฝ์ ์ ์ค๋ ํ๋ฃจ ๋์ ์ฐ๋ค.
- ์์ ์กฐ๊ฑด์ ์ํด ์ด์ด์ผํ๋ ๊ตญ๊ฒฝ์ ์ด ๋ชจ๋ ์ด๋ ธ๋ค๋ฉด, ์ธ๊ตฌ ์ด๋์ ์์ํ๋ค.
- ๊ตญ๊ฒฝ์ ์ด ์ด๋ ค์์ด ์ธ์ ํ ์นธ๋ง์ ์ด์ฉํด ์ด๋ํ ์ ์์ผ๋ฉด, ๊ทธ ๋๋ผ๋ฅผ ์ค๋ ํ๋ฃจ ๋์์ ์ฐํฉ์ด๋ผ๊ณ ํ๋ค.
- ์ฐํฉ์ ์ด๋ฃจ๊ณ ์๋ ๊ฐ ์นธ์ ์ธ๊ตฌ์๋ (์ฐํฉ์ ์ธ๊ตฌ์) / (์ฐํฉ์ ์ด๋ฃจ๊ณ ์๋ ์นธ์ ๊ฐ์)๊ฐ ๋๋ค. ํธ์์ ์์์ ์ ๋ฒ๋ฆฐ๋ค.
- ์ฐํฉ์ ํด์ฒดํ๊ณ , ๋ชจ๋ ๊ตญ๊ฒฝ์ ์ ๋ซ๋๋ค.
๊ฐ ๋๋ผ์ ์ธ๊ตฌ์๊ฐ ์ฃผ์ด์ก์ ๋, ์ธ๊ตฌ ์ด๋์ด ๋ฉฐ์น ๋์ ๋ฐ์ํ๋์ง ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ N, L, R์ด ์ฃผ์ด์ง๋ค. (1 ≤ N ≤ 50, 1 ≤ L ≤ R ≤ 100)
๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ ๊ฐ ๋๋ผ์ ์ธ๊ตฌ์๊ฐ ์ฃผ์ด์ง๋ค. rํ c์ด์ ์ฃผ์ด์ง๋ ์ ์๋ A[r][c]์ ๊ฐ์ด๋ค. (0 ≤ A[r][c] ≤ 100)
์ธ๊ตฌ ์ด๋์ด ๋ฐ์ํ๋ ์ผ์๊ฐ 2,000๋ฒ ๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ๋ ฅ๋ง ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ธ๊ตฌ ์ด๋์ด ๋ฉฐ์น ๋์ ๋ฐ์ํ๋์ง ์ฒซ์งธ ์ค์ ์ถ๋ ฅํ๋ค.
์์ ์ ๋ ฅ1
2 20 50
50 30
20 40
์์ ์ถ๋ ฅ1
1
ํ์ด
- BFS(๋๋น์ฐ์ ํ์) ์ฌ์ฉ
- ํ์ด ๋ฐฉ๋ฒ(๋ค๋ฅธ ์ฌ๋ ํ์ด ์ฐธ๊ณ )
- bfs ํจ์์์ temp ๋ฐฐ์ด์ ๊ตญ๊ฒฝ์ ์ ๊ณต์ ํ๊ณ ์๋ ๋๋ผ๋ค์ ๊ตฌํ์ฌ ์ขํ๊ฐ์ ๋ฃ์ด์ค๋ค
- flag = 1์ ์ ์ธํ๊ณ ์ธ๊ตฌ์ด๋์ ์์ํ๋ค. ์ฐํฉ์ ์ด๋ฃจ๊ณ ์๋ ์ธ๊ตฌ์๋ฅผ ๊ณ์ฐํด์ฃผ๊ณ , temp ๋ฐฐ์ด์ ๋ด๊ธด ๋๋ผ๋ค์ ์ธ๊ตฌ ์ด๋์ ํด์ค๋ค
- while๋ฌธ์ด ๋ ๋๋ง๋ค result ์ ์ธ๊ตฌ ์ด๋์ ํ ํ์๋ฅผ ๋ํด์ค๋ค(+1)
- ์ธ๊ตฌ ์ด๋์ด ๋๋๋ฉด(flag == 0์ด๋ฉด) while๋ฌธ ์ข ๋ฃ
# ์ผ์ฑ SW ์ญ๋ ํ
์คํธ ๊ธฐ์ถ ๋ฌธ์
# ๋ฐฑ์ค 16234๋ฒ. ์ธ๊ตฌ ์ด๋
# BFS
import sys
from collections import deque
N, L, R = map(int, input().split())
land = [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
dx = [0, 0, 1, -1]
dy = [1, -1, 0, 0]
def bfs(a, b):
queue = deque()
temp = [] # ๊ตญ๊ฒฝ์ ์ ๊ณต์ ํ๊ณ ์๋ ๋๋ผ๋ค์ ์ขํ๊ฐ ๋ฃ์ ๋ฐฐ์ด
queue.append((a, b))
temp.append((a, b))
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 < N and visited[nx][ny] == 0:
# ๊ตญ๊ฒฝ์ ์ด๊ธฐ
if L <= abs(land[nx][ny] - land[x][y]) <= R:
visited[nx][ny] = 1
queue.append((nx, ny))
temp.append((nx, ny))
return temp
result = 0 # ์ธ๊ตฌ ์ด๋์ด ํ์ํ ๋ ์ง ์
while 1:
visited = [[0] * (N + 1) for _ in range(N + 1)]
flag = 0 # ์ธ๊ตฌ์ด๋ ์์์ 1, ๋๋๋ฉด 0
for i in range(N):
for j in range(N):
if visited[i][j] == 0:
visited[i][j] = 1
country = bfs(i, j)
# ์์ ์กฐ๊ฑด์ ์ํด ์ด์ด์ผํ๋ ๊ตญ๊ฒฝ์ ์ด ๋ชจ๋ ์ด๋ ธ์ผ๋ฉด ์ธ๊ตฌ์ด๋ ์์
if len(country) > 1:
flag = 1
# ์ฐํฉ์ ์ด๋ฃจ๊ณ ์๋ ์ธ๊ตฌ์ ๊ณ์ฐ
number = sum(land[x][y] for x, y in country) // len(country)
for x, y in country:
land[x][y] = number
# ์ฐํฉ ํด์ฒดํ๊ณ ๋ชจ๋ ๊ตญ๊ฒฝ์ ๋ซ๊ธฐ
if flag == 0:
break
result += 1 # while๋ฌธ ๋๋๋ง๋ค + 1(์ธ๊ตฌ์ด๋ ํ ํ์)
print(result)
์๊ณ ๋ฆฌ์ฆ ๋ถ๋ฅ
- ๊ทธ๋ํ ์ด๋ก
- ๊ทธ๋ํ ํ์
- ๋๋น ์ฐ์ ํ์
- ์๋ฎฌ๋ ์ด์
์ฐธ๊ณ ์ฌ์ดํธ