๐ฌ ์ฐ๊ตฌ์
- ์๊ฐ์ ํ: 2์ด
- ๋ฉ๋ชจ๋ฆฌ ์ ํ: 512MB
๐ ๋ฌธ์
- ์ธ์ฒด์ ์น๋ช ์ ์ธ ๋ฐ์ด๋ฌ์ค๋ฅผ ์ฐ๊ตฌํ๋ ์ฐ๊ตฌ์์์ ๋ฐ์ด๋ฌ์ค๊ฐ ์ ์ถ๋์๋ค. ๋คํํ ๋ฐ์ด๋ฌ์ค๋ ์์ง ํผ์ง์ง ์์๊ณ , ๋ฐ์ด๋ฌ์ค์ ํ์ฐ์ ๋ง๊ธฐ ์ํด์ ์ฐ๊ตฌ์์ ๋ฒฝ์ ์ธ์ฐ๋ ค๊ณ ํ๋ค.
- ์ฐ๊ตฌ์๋ ํฌ๊ธฐ๊ฐ N x M์ธ ์ง์ฌ๊ฐํ์ผ๋ก ๋ํ๋ผ ์ ์์ผ๋ฉฐ, ์ง์ฌ๊ฐํ์ 1 x 1 ํฌ๊ธฐ์ ์ ์ฌ๊ฐํ์ผ๋ก ๋๋์ด์ ธ ์๋ค. ์ฐ๊ตฌ์๋ ๋น ์นธ, ๋ฒฝ์ผ๋ก ์ด๋ฃจ์ด์ ธ ์์ผ๋ฉฐ, ๋ฒฝ์ ์นธ ํ๋๋ฅผ ๊ฐ๋ ์ฐจ์งํ๋ค.
- ์ผ๋ถ ์นธ์ ๋ฐ์ด๋ฌ์ค๊ฐ ์กด์ฌํ๋ฉฐ, ์ด ๋ฐ์ด๋ฌ์ค๋ ์ํ์ข์ฐ๋ก ์ธ์ ํ ๋น ์นธ์ผ๋ก ๋ชจ๋ ํผ์ ธ๋๊ฐ ์ ์๋ค.
- ์๋ก ์ธ์ธ ์ ์๋ ๋ฒฝ์ ๊ฐ์๋ 3๊ฐ์ด๋ฉฐ, ๊ผญ 3๊ฐ๋ฅผ ์ธ์์ผ ํ๋ค.
- ์๋ฅผ ๋ค์ด, ์๋์ ๊ฐ์ด ์ฐ๊ตฌ์๊ฐ ์๊ธด ๊ฒฝ์ฐ๋ฅผ ์ดํด๋ณด์.
- ์ด๋, 0์ ๋น ์นธ, 1์ ๋ฒฝ, 2๋ ๋ฐ์ด๋ฌ์ค๊ฐ ์๋ ๊ณณ์ด๋ค. ์๋ฌด๋ฐ ๋ฒฝ์ ์ธ์ฐ์ง ์์๋ค๋ฉด, ๋ฐ์ด๋ฌ์ค๋ ๋ชจ๋ ๋น ์นธ์ผ๋ก ํผ์ ธ๋๊ฐ ์ ์๋ค.
- 2ํ 1์ด, 1ํ 2์ด, 4ํ 6์ด์ ๋ฒฝ์ ์ธ์ด๋ค๋ฉด ์ง๋์ ๋ชจ์์ ์๋์ ๊ฐ์์ง๊ฒ ๋๋ค.
- ๋ฐ์ด๋ฌ์ค๊ฐ ํผ์ง ๋ค์ ๋ชจ์ต์ ์๋์ ๊ฐ์์ง๋ค.
- ๋ฒฝ์ 3๊ฐ ์ธ์ด ๋ค, ๋ฐ์ด๋ฌ์ค๊ฐ ํผ์ง ์ ์๋ ๊ณณ์ ์์ ์์ญ์ด๋ผ๊ณ ํ๋ค.
- ์์ ์ง๋์์ ์์ ์์ญ์ ํฌ๊ธฐ๋ 27์ด๋ค.
- ์ฐ๊ตฌ์์ ์ง๋๊ฐ ์ฃผ์ด์ก์ ๋ ์ป์ ์ ์๋ ์์ ์์ญ ํฌ๊ธฐ์ ์ต๋๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
- ์ฒซ์งธ ์ค์ ์ง๋์ ์ธ๋ก ํฌ๊ธฐ N๊ณผ ๊ฐ๋ก ํฌ๊ธฐ M์ด ์ฃผ์ด์ง๋ค.( 3 <= N, M <= 8)
- ๋์งธ ์ค ๋ถํฐ N๊ฐ์ ์ค์ ์ง๋์ ๋ชจ์์ด ์ฃผ์ด์ง๋ค. 0์ ๋น ์นธ, 1์ ๋ฒฝ, 2๋ ๋ฐ์ด๋ฌ์ค๊ฐ ์๋ ์์น์ด๋ค.
- 2์ ๊ฐ์๋ 2๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 10๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๋ค.
- ๋น ์นธ์ ๊ฐ์๋ 3๊ฐ ์ด์์ด๋ค.
์ถ๋ ฅ
- ์ฒซ์งธ ์ค์ ์ป์ ์ ์๋ ์์ ์์ญ์ ์ต๋ ํฌ๊ธฐ๋ฅผ ์ถ๋ ฅํ๋ค.
๐ก ๋ฌธ์ ์์ด๋์ด
- bfs/dfs๋ฌธ์ ์ธ ๊ฒ ๊ฐ์๋ฐ ์ด๋ฅผ ํ์ฉํ์ฌ ์ด๋ค ๋ฐฉ์์ผ๋ก ๊ตฌํํด์ผ ํ ์ง ๊ฐ์ด ์ค์ง ์์์ ๋ค๋ฅธ ์ฌ๋ ํ์ด์์ ์ฃผ์์ ํตํด ๋ก์ง๋ง ์ฐธ๊ณ
- ํ๋์ฉ ํ์ค๋ฅผ ์น๋ค.
- ํ์ค๊ฐ 3๊ฐ๊ฐ ๋๋ฉด ๋ฐ์ด๋ฌ์ค ์ ํํด์ ์์ ์์ญ ์ผ๋ค.
- 3๊ฐ ๋ฏธ๋ง์ด๋ฉด ํ์ค ๊ณ์ ์น๊ธฐ
- ํ๋์ฉ ํ์ค๋ฅผ ์น๋ค.
โ ์ ๋ต ์ฝ๋ (ํ์ด ์ฐธ๊ณ + GPT ํ์ฉ)
# ์ฐ๊ตฌ์
from sys import stdin
from collections import deque
import copy
input = stdin.readline
# ์ธ๋ก, ๊ฐ๋ก ์
๋ ฅ
N, M = map(int, input().split())
# ์ฐ๊ตฌ์ ์ง๋ ์
๋ ฅ
lab = [list(map(int, input().split())) for _ in range(N)]
# ๋ฐ์ด๋ฌ์ค ์์น ์ ์ฅ
viruses = []
# ๋น๊ณณ ์์น ์ ์ฅ
empty_spaces = []
for i in range(N):
for j in range(M):
if lab[i][j] == 2:
viruses.append((i, j))
elif lab[i][j] == 0:
empty_spaces.append((i, j))
# ์์ ์์ญ ์ต๋๊ฐ ์ ์ฅ
max_safe = -1
def virus_and_return_safe():
global result
directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
temp_lab = copy.deepcopy(lab)
queue = deque(viruses)
while queue:
x, y = queue.popleft()
for dx, dy in directions:
nx, ny = x + dx, y + dy
if 0 <= nx < N and 0 <= ny < M and temp_lab[nx][ny] == 0:
temp_lab[nx][ny] = 2
queue.append((nx, ny))
cnt = 0
for i in range(N):
cnt += temp_lab[i].count(0)
result = max(result, cnt)
def make_wall(cnt, index):
if cnt == 3:
virus_and_return_safe()
return
for i in range(index, len(empty_spaces)):
x, y = empty_spaces[i]
lab[x][y] = 1
make_wall(cnt + 1, i + 1)
lab[x][y] = 0 # ๋ฐฑํธ๋ํน
result = 0
make_wall(0, 0)
print(result)
728x90
'Algorithm&CodingTest > Baekjoon' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Baekjoon][1021] ์ค๋ฒ2 ์ ๊ธฐ๋ ๋ฐฐ์ถ - Python (0) | 2024.10.08 |
---|---|
[Baekjoon][14499] ๊ณจ๋4 ์ฃผ์ฌ์ ๊ตด๋ฆฌ๊ธฐ - Python (0) | 2024.10.08 |
[Baekjoon][2206] ๊ณจ๋3 ๋ฒฝ ๋ถ์๊ณ ์ด๋ํ๊ธฐ - Python (0) | 2024.10.08 |
[Beakjoon][7576] ๊ณจ๋5 - ํ ๋งํ Python (0) | 2024.10.07 |
[Beakjoon][19637] ์ค๋ฒ3 - IF๋ฌธ ์ข ๋์ ์จ์ค Python (0) | 2024.05.05 |