https://www.acmicpc.net/problem/2606
2606๋ฒ: ๋ฐ์ด๋ฌ์ค
์ฒซ์งธ ์ค์๋ ์ปดํจํฐ์ ์๊ฐ ์ฃผ์ด์ง๋ค. ์ปดํจํฐ์ ์๋ 100 ์ดํ์ด๊ณ ๊ฐ ์ปดํจํฐ์๋ 1๋ฒ ๋ถํฐ ์ฐจ๋ก๋๋ก ๋ฒํธ๊ฐ ๋งค๊ฒจ์ง๋ค. ๋์งธ ์ค์๋ ๋คํธ์ํฌ ์์์ ์ง์ ์ฐ๊ฒฐ๋์ด ์๋ ์ปดํจํฐ ์์ ์๊ฐ ์ฃผ์ด
www.acmicpc.net
์คํ ๋ค๋ํ ๊ทธ๋ํ ํ์ ๋ฌธ์ ์ด๋ค.
- DFS ํ์ด
์ปดํจํฐ(๋ ธ๋) ๊ฐ์ ์ฐ๊ฒฐ ์ ๋ณด๋ graph๋ผ๋ ์ด์ฐจ์ ๋ฐฐ์ด์ ์ ์ฅํ๋ค.
graph[n]์๋ n๋ฒ ์ปดํจํฐ์ ์ฐ๊ฒฐ๋ ์ปดํจํฐ๋ค์ ์ ์ฅํ๋ค.
์๋ฅผ ๋ค์ด 1๋ฒ ์ปดํจํฐ๊ฐ 2, 4๋ฒ ์ปดํจํฐ์ ์ฐ๊ฒฐ๋์ด ์๋ค๋ฉด graph[1] = [2, 4]๊ฐ ๋๋ค.
๊ทธ๋ค์ ๊ทธ๋ํ์ ์ปดํจํฐ๋ค ๊ฐ์ ์ฐ๊ฒฐ๊ด๊ณ๋ฅผ input ๋ฐ์์ ์ ์ฅํ๋ค.
1๋ฒ๊ณผ 2๋ฒ ์ปดํจํฐ๊ฐ ์๋ก ์ฐ๊ฒฐ๋์ด ์๋ค๋ฉด graph[1]์๋ 2๋ฅผ append ํด์ฃผ๊ณ , graph[2]์๋ 1์ append ํด์ค์ผ ํ๋ค.
๊ทธ๋ํ ํ์์ ํ ๋ ์ด๋ฏธ ์ฒดํฌํ ์ปดํจํฐ๋ฅผ ๋ ํ์ธํ๊ณ ๋ ํ์ธํ๋ฉด ์๊ฐ ์ด๊ณผ๊ฐ ๋๋ค.
๊ทธ๋์ ์ฒดํฌ ์ฌ๋ถ๋ฅผ ์ ์ฅํด์ฃผ๊ธฐ ์ํด checked ๋ฐฐ์ด์ ๋ง๋ค์ด์ค๋ค.
๋ณดํต int ๋ฐฐ์ด๋ก ์ ์ธํ๊ณ 1, 0์ผ๋ก ์ฐ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์๋ฐ, ๋๋ ์ทจํฅ๊ป boolean ๋ฐฐ์ด๋ก ๋ง๋ค์๋ค.
1๋ฒ ์ปดํจํฐ๋ ์ฒ์๋ถํฐ ๊ฐ์ผ๋์ด ์์ ๊ฑฐ๋๊น True๋ก ์ด๊ธฐํํ๋ค.
์ด์ ๋ณธ๊ฒฉ์ ์ธ ๊ฐ์ผ ์ ํ๋ฅผ ์์ํ ๊ฒ์ด๋ค.
stack์ด๋ผ๋ ์คํ ๋ฆฌ์คํธ์ ์ ์ฅํ ์ปดํจํฐ๋ ๋ฐฉ๊ธ ๋ง ๊ฐ์ผ๋ ์ปดํจํฐ๋ค์ด๋ค.
์์ํ ๋๋ ๊ฐ์ผ์์ธ 1๋ง ๋ด๊ฒจ ์๋ค.
์ด ์ปดํจํฐ์ ์ฐ๊ฒฐ๋ ์ปดํจํฐ๋ค์ ๊ฐ์ผ์์ผ์ผ ํ๋ค.
while๋ฌธ์ ๋๋ ค๋ณด์.
์ผ๋จ ์ต๊ทผ์ ๊ฐ์ผ๋ ์ปดํจํฐ๋ฅผ pop ํ๋ค. ์ด๋ฆ์ curr๋ผ๊ณ ๋ถ์๋ค.
curr์ ์ฐ๊ฒฐ๋ ์ปดํจํฐ๋ค์ ๋ด์ ๋ฆฌ์คํธ๊ฐ graph[curr]์ด๋๊น ๊ทธ ์์ ๋ด๊ฒจ์๋ ์ปดํจํฐ๋ค์ ํ์ํ๋ค.
curr๊ณผ ์ฐ๊ฒฐ๋ next ์ปดํจํฐ ์ค์ ์์ง ์ฒดํฌ๋ฅผ ์ ํ ์ปดํจํฐ๊ฐ ์๋ค๋ฉด checked[next]๋ฅผ True๋ก ๊ฐฑ์ ํด ์ค๋ค.
๋ฐฉ๊ธ ๋ง ๊ฐ์ผ๋๋ค. stack์ append ํด์ฃผ๋ฉด ๋๋ค.
stack ๋ฌด์ธ๊ฐ๊ฐ ๋ด๊ฒจ์๋ ํ ๊ณ์ ํ์์ ํ๋ค.
์ฐ๊ฒฐ๋ ๋ชจ๋ ์ปดํจํฐ๊ฐ ๊ฐ์ผ์ด ๋์๋ค๋ฉด stack์ด ๋น๊ฒ ๋๊ณ , while๋ฌธ์ด break ๋ ๊ฒ์ด๋ค.
checked์ ์ฒดํฌ๋ ์ปดํจํฐ, ์ฆ ๊ฐ์ผ๋ ์ปดํจํฐ์ ์๋ checked์์ True์ ๊ฐ์๋ฅผ ์นด์ดํธํด์ฃผ๋ฉด ์ ์ ์๋ค.
๋ค๋ง, 1๋ฒ ์ปดํจํฐ๋ ์๋๋ถํฐ ๊ฐ์ผ๋์ด ์์์ผ๋ฏ๋ก ๋ต์์ 1์ ๋นผ์ผ ํ๋ค.
N = int(input()) # ์ปดํจํฐ์ ๊ฐ์
graph = [[] for _ in range(N+1)] # graph[n]์๋ n๋ฒ ์ปดํจํฐ์ ์ฐ๊ฒฐ๋ ์ปดํจํฐ๋ค์ ์ ์ฅ
# ๊ทธ๋ํ์ ์ปดํจํฐ๋ค ๊ฐ์ ์ฐ๊ฒฐ ๊ด๊ณ ์ ์ฅ
for _ in range(int(input())):
a, b = map(int, input().split())
graph[a].append(b)
graph[b].append(a)
# ์ฒดํฌ ์ฌ๋ถ ์ ์ฅํ ๋ฐฐ์ด
checked = [False] * (N+1)
checked[1] = True
# 1๋ฒ ์ปดํจํฐ์์ ๋ฐ์ด๋ฌ์ค ์์
stack = [1]
# DFS
while stack: # ๋ ์ด์ ํ์ธํ ์ปดํจํฐ๊ฐ ์์ผ๋ฉด break
curr = stack.pop() # ์ต๊ทผ์ ๊ฐ์ผ๋ ์ปดํจํฐ๋ถํฐ ํ์ธ
for next in graph[curr]: # curr ๋ฒ ์ปดํจํฐ์ ์ฐ๊ฒฐ๋ ์ปดํจํฐ๋ค ์ํ
if not checked[next]: # ์์ง ์ฒดํฌ ์ํ ์ปดํจํฐ๋ผ๋ฉด
checked[next] = True # ์ฒดํฌ
stack.append(next) # ์ด ์ปดํจํฐ๋ ์ฐ๊ฒฐ๋ ์ปดํจํฐ๋ ์ฒดํฌํ ๊ฑฐ์
print(checked.count(True)-1) # 1๋ฒ ์ปดํจํฐ ๋นผ๊ณ ๊ฐ์ผ๋ ์ปดํจํฐ์ ์ ์ถ๋ ฅ
์ด ํ์ด๊ฐ DFS์ธ ์ด์ ๋ stack์์ pop ํด๊ฐ๋ฉฐ ๋ค์ ์ปดํจํฐ๋ฅผ ํ์ํ๋ ๋ฐฉ๋ฒ ์ด์ด์๋ค.
1๋ฒ ์ปดํจํฐ์ 2, 4๋ฒ์ด ์ฐ๊ฒฐ๋์ด ์๋ ๊ฒฝ์ฐ๋ผ๊ณ ์น๋ฉด,
1๋ฒ > 2๋ฒ > 2๋ฒ์ ์ฐ๊ฒฐ๋ ๋ญ์๊ธฐ > ๋ญ์๊ธฐ์ ์ฐ๊ฒฐ๋ ์ ์๊ธฐ ์์ผ๋ก ํ์ํ๊ฒ ๋๊ธฐ ๋๋ฌธ์ด๋ค.
์ ์๊ธฐ์ ์ ์๊ธฐ๊น์ง ๋๊น์ง ํ์์ ํ๋ฉด ๊ทธ์ ์์ผ 4๋ฒ ์ปดํจํฐ๋ฅผ ํ์ํ๊ฒ ๋๋ค.
BFS์ ๊ฒฝ์ฐ์๋ 1๋ฒ >> 2๋ฒ > 4๋ฒ >> 2๋ฒ์ ์ฐ๊ฒฐ๋ ๋ญ์๊ธฐ๋ค > 4๋ฒ์ ์ฐ๊ฒฐ๋ ๋ญ์๊ธฐ๋ค ... ์ด๋ฐ ์์๋ก ํ์ํ๊ฒ ๋๋ค.
์ฌ์ค ์ด๋ป๊ฒ ํ์ํด๋ ์๊ด์๋ ๋ฌธ์ ์ด๋ค.
์ด๋ฐ ๊ฒฝ์ฐ์๋ ์คํ ์๋ฃํ์ ์ฌ์ฉํ๋ DFS ํ์ด๊ฐ ๋ ๊ท์ฐฎ์ง๋ง ๊ณต๋ถํ๊ธฐ ์ํด์ BFS๋ก ํ์ด๋ด๋ ์ข๋ค.
- BFS ํ์ด
from collections import deque
N = int(input())
graph = [[] for _ in range(N+1)]
for _ in range(int(input())):
a, b = map(int, input().split())
graph[a].append(b)
graph[b].append(a)
visited = [False] * (N+1)
visited[1] = True
queue = deque([1])
while queue:
curr = queue.popleft()
for next in graph[curr]:
if not visited[next]:
visited[next] = True
queue.append(next)
print(visited.count(True)-1)
DFS ํ์ด์ ๋๊ฐ๋ค.
์คํ์ด ์๋ ๋ฑ์ ์ฌ์ฉํ๋จ ๊ฒ๋ง ๋ค๋ฅด๋ค.
์ฌ์ค ๊ทธ๋ฅ queue๋ฅผ ์ฐ๋ฉด ๋๋๋ฐ, ํ์ด์ฌ์์๋ ํ๋ณด๋ค ๋ฑ์ด ๋น ๋ฅด๋ค. ๋ฌผ๋ก ํ๋ฅผ ์จ๋ ์ด๋ฌธ์ ๋ ํต๊ณผ๋๋ค.
๋ค์์ pop ํด์ ์ฐ๋ ์คํ๊ณผ ๋ฌ๋ฆฌ ์์์ popleft ํด์ ํ์ํ๊ฒ ๋ผ์ 1๋ฒ ์ปดํจํฐ์ ์ฐ๊ฒฐ๋ ์ฐจ์ ์์๋๋ก ํ์ํ ์ ์๊ฒ ๋๊ฒ ๋ค.
์ข ๋ ์ค๋ฒํ์๋ฉด ์ฐ๊ฒฐ ๊ด๊ณ๋ฅผ ํ์ธํ๋ ๋ฌธ์ ๋๊น ์ ๋์จ ํ์ธ๋๋ฅผ ์ด์ฉํด์๋ ํ ์ ์๋ค.