๐๋ฌธ์ ๋ณด๋ฌ๊ฐ๊ธฐ
๋ฌธ์ ์ค๋ช
์ ๋ก์์ฝ์ ๋นจ๊ฐ์๊ณผ ์ด๋ก์์ ์ฐจ์ด๋ฅผ ๊ฑฐ์ ๋๋ผ์ง ๋ชปํ๋ค. ๋ฐ๋ผ์, ์ ๋ก์์ฝ์ธ ์ฌ๋์ด ๋ณด๋ ๊ทธ๋ฆผ์ ์๋ ์ฌ๋์ด ๋ณด๋ ๊ทธ๋ฆผ๊ณผ๋ ์ข ๋ค๋ฅผ ์ ์๋ค. ํฌ๊ธฐ๊ฐ N×N์ธ ๊ทธ๋ฆฌ๋์ ๊ฐ ์นธ์ R(๋นจ๊ฐ), G(์ด๋ก), B(ํ๋) ์ค ํ๋๋ฅผ ์์น ํ ๊ทธ๋ฆผ์ด ์๋ค. ๊ทธ๋ฆผ์ ๋ช ๊ฐ์ ๊ตฌ์ญ์ผ๋ก ๋๋์ด์ ธ ์๋๋ฐ, ๊ตฌ์ญ์ ๊ฐ์ ์์ผ๋ก ์ด๋ฃจ์ด์ ธ ์๋ค. ๋, ๊ฐ์ ์์์ด ์ํ์ข์ฐ๋ก ์ธ์ ํด ์๋ ๊ฒฝ์ฐ์ ๋ ๊ธ์๋ ๊ฐ์ ๊ตฌ์ญ์ ์ํ๋ค. (์์์ ์ฐจ์ด๋ฅผ ๊ฑฐ์ ๋๋ผ์ง ๋ชปํ๋ ๊ฒฝ์ฐ๋ ๊ฐ์ ์์์ด๋ผ ํ๋ค)
์๋ฅผ ๋ค์ด, ๊ทธ๋ฆผ์ด ์๋์ ๊ฐ์ ๊ฒฝ์ฐ์
RRRBB
GGBBB
BBBRR
BBRRR
RRRRR
์ ๋ก์์ฝ์ด ์๋ ์ฌ๋์ด ๋ดค์ ๋ ๊ตฌ์ญ์ ์๋ ์ด 4๊ฐ์ด๋ค. (๋นจ๊ฐ 2, ํ๋ 1, ์ด๋ก 1) ํ์ง๋ง, ์ ๋ก์์ฝ์ธ ์ฌ๋์ ๊ตฌ์ญ์ 3๊ฐ ๋ณผ ์ ์๋ค. (๋นจ๊ฐ-์ด๋ก 2, ํ๋ 1) ๊ทธ๋ฆผ์ด ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ก์ ๋, ์ ๋ก์์ฝ์ธ ์ฌ๋์ด ๋ดค์ ๋์ ์๋ ์ฌ๋์ด ๋ดค์ ๋ ๊ตฌ์ญ์ ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ N์ด ์ฃผ์ด์ง๋ค. (1 ≤ N ≤ 100)
๋์งธ ์ค๋ถํฐ N๊ฐ ์ค์๋ ๊ทธ๋ฆผ์ด ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ ๋ก์์ฝ์ด ์๋ ์ฌ๋์ด ๋ดค์ ๋์ ๊ตฌ์ญ์ ๊ฐ์์ ์ ๋ก์์ฝ์ธ ์ฌ๋์ด ๋ดค์ ๋์ ๊ตฌ์ญ์ ์๋ฅผ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํด ์ถ๋ ฅํ๋ค.
์์ ์ ์ถ๋ ฅ
ํ์ด ์ ๋ต
DFS/BFS์ ์ทจ์ฝํ๋ค๋ ๊ฑธ ๊นจ๋ซ๊ณ , ์ฐ์ DFS ๋ฌธ์ ๋ถํฐ ํ์ด ๋ด์ผ์ง ํ๊ณ ๋ฐฑ์ค ์จ๋ผ์ธ ์ ์ง์ ๋ค์ด๊ฐ ๋ดค๋ค.
๊ทธ๋ฆฌ๊ณ ๋ง์ฃผํ๊ฒ ๋ ๋ฌธ์ ๊ฐ ๋ฐ๋ก ๋ค์ ๋ฌธ์ ์๋ค. ๋์ค์ ํ์ธํ ์ฌ์ค์ธ๋ฐ, ๋์ด๋ ๊ณจ๋ 5์ง๋ฆฌ ๋ฌธ์ ์๋ค. ์ฒ์ ๋์ ํ๋ ๋์๊ฒ๋ ๋ฒ ์ฐฌ ์์ค์ด ์๋์์๊น?.... ํ์๋ ์ ๋ต์ ์๊ฐํ์๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
- ์์ ์์น์ ์๊น ์ ๋ณด๋ฅผ ๊ฐ์ง๊ณ , ์ฃผ๋ณ์ ๊ฐ์ ์๊น์ ๊ฐ์ง ๊ฒ ์๋์ง ์, ํ, ์ข, ์ฐ ๋ฐฉํฅ์ผ๋ก ์ต๋ ๊น์ด๊น์ง ๋ค์ด๊ฐ๋ค.
- ๋ฐฉ๋ฌธํ ๊ณณ์ ๋ณ๋์ ๋ฌธ์๋ก ํ์ํ๋ค.
- ์ธ๋ฑ์ค๋ฅผ ๋ฒ์ด๋๊ฑฐ๋, ๋ ์ด์ ๊ฐ์ ์๊น์ ๊ฐ์ง ๊ฒ ์์ผ๋ฉด ํ์์ ์ข ๋ฃํ๋ค.
- 2์ฐจ์ ๋ฆฌ์คํธ๋ฅผ ์ํํ๋ฉฐ, ๋ฐฉ๋ฌธํ๋ ๊ณณ์ ์๋ตํ ์ฑ๋ก DFS๋ฅผ ๊ณ์ ์งํํ๋ค.
์์ค ์ฝ๋ ๋ฐ ๊ฒฐ๊ณผ
import sys
sys.setrecursionlimit(10**6) # ์ฌ๊ทํจ์ ํธ์ถ ํ๊ณ์น๋ฅผ ๋๋ฆฌ๊ธฐ ์ํด ํ์
n = int(input())
graph = []
# ์๊น ์ ๋ณด ๋ฐ๊ธฐ
for _ in range(n):
graph.append(list(input()))
def DFS(graph, color, x, y, hasBlind):
if x < 0 or x >= n or y < 0 or y >= n: # ์ ํจํ ์ธ๋ฑ์ค๊ฐ ์๋๋ผ๋ฉด ์ข
๋ฃ
return False
if hasBlind: # ์ ๋ก์์ฝ์ ๊ฐ์ง ์ฌ๋์ผ ๊ฒฝ์ฐ
if (graph[x][y] == 'R' or graph[x][y] == 'G') and (color == 'R' or color == 'G'):
color = graph[x][y]
if graph[x][y] == color: # ๊ฐ์ ์๊น์ผ ๊ฒฝ์ฐ
graph[x][y] = '#' # ๋ฐฉ๋ฌธ ์ฒ๋ฆฌ
DFS(graph, color, x - 1, y, hasBlind) # ์
DFS(graph, color, x + 1, y, hasBlind) # ํ
DFS(graph, color, x, y - 1, hasBlind) # ์ข
DFS(graph, color, x, y + 1, hasBlind) # ์ฐ
# ์ฃผ๋ณ์ ๋ค์ ํ์
return True # ๋ชจ๋ DFS๋ฅผ ๋ง์ณค์ ๊ฒฝ์ฐ
return False # ์ฃผ๋ณ์ ๊ฐ์ ์๊น์ธ ๊ฒ ์์ ๊ฒฝ์ฐ
generalResult = 0
blindnessResult = 0
generalGraph = [_list.copy() for _list in graph]
blindGraph = [_list.copy() for _list in graph]
for i in range(n):
for j in range(n):
if generalGraph[i][j] != '#':
if DFS(generalGraph, generalGraph[i][j], i, j, False): # ์ผ๋ฐ ์ฌ๋์ผ ๊ฒฝ์ฐ
generalResult += 1
if blindGraph[i][j] != '#':
if DFS(blindGraph, blindGraph[i][j], i, j, True): # ์ ๋ก์์ฝ์ด ์๋ ์ฌ๋์ผ ๊ฒฝ์ฐ
blindnessResult += 1
print(generalResult, blindnessResult, end = ' ')
<์ด๊ฒ์ด ์ฝ๋ฉ ํ ์คํธ๋ค. with ํ์ด์ฌ> ์ฑ ์ ์์ ๋ฅผ ๋ณด๋ฉฐ ๊ณต๋ถํ๋ DFS ์ฝ๋๋ฅผ ์ฌ์ฉํ์ฌ ๋ง๋ถ์๋ค.
Visual Studio Code์ ๋๋ฒ๊น ๊ธฐ๋ฅ์ ํตํด ์ฝ๋๊ฐ ์ด๋ป๊ฒ ์งํ๋๋์ง๋ฅผ ๋ณด๋ฉด์ ํ์ธํด๋ดค๋ค.
๊ทธ๋ฆฌ๊ณ DFS ๊ตฌํ์ ์ํด, ์ฌ๊ท ํจ์๋ฅผ ์ฌ์ฉํ๋๋ฐ ๋ฐํ์ ์๋ฌ๊ฐ ์๊พธ ๋ด์๋ค.
์๊ณ ๋ณด๋, ํ์ด์ฌ์ ๊ธฐ๋ณธ ์ฌ๊ท ๊น์ด ์ ํ์ด 1000์ ๋๋ผ ์์์ ๋ฐ์ํ ๋ฌธ์ ์๋ค.
๊ทธ๋์ ํ์ด์ฌ์ผ๋ก ์ฝ๋ฉ ํ ์คํธ๋ฅผ ๋ณผ ๊ฑฐ๋ฉด, ๋ค์ ์ฝ๋๋ฅผ ํตํด ์ฌ๊ท ํจ์ ํธ์ถ ํ๊ณ์น๋ฅผ ๋๋ ค์ฃผ๊ณ ์์ํ๋ ๊ฒ์ด ์ข๋ค๊ณ ํ๋ค.
import sys
sys.setrecursionlimit(10 ** 6) # 1000000๋ฒ์ผ๋ก ํธ์ถ ํ๊ณ์น ์ค์
'๐คAlgorithm > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[BOJ] 10162๋ฒ | ์ ์๋ ์ธ์ง (Python3) (0) | 2022.07.14 |
---|---|
[BOJ] 2217๋ฒ | ๋กํ (Python3) (0) | 2022.07.14 |
[BOJ] 5585๋ฒ | ๊ฑฐ์ค๋ฆ๋ (Python3) (0) | 2022.07.13 |
[BOJ] 1541๋ฒ | ์์ด๋ฒ๋ฆฐ ๊ดํธ (Python3) (0) | 2022.07.12 |
[BOJ] 1026๋ฒ | ๋ณด๋ฌผ (Python3) (0) | 2022.07.07 |