2660 - ํ์ฅ๋ฝ๊ธฐ
ํธ๋ฆฌ๊ฐ ํ๋ ์ฃผ์ด์ง๋ฉด ๋ ธ๋ ํ๋๋ฅผ ์ก๊ณ ์ด ๋ ธ๋๋ฅผ ํ์์ด๋ผ๊ณ ํฉ์๋ค. ์ด ํ์๊ณผ ์ด์ด์ง ๋ ธ๋๋ ํ์์ ์น๊ตฌ์ด๊ณ , ํ์๊ณผ ์ด์ด์ง ๋ ธ๋์ ์ด์ด์ง ๋ ธ๋๋ ํ์์ ์น๊ตฌ์ ์น๊ตฌ์ ๋๋ค. ํ์์ด ๋ชจ๋์ ์น๊ตฌ๋ผ๋ฉด (ํด๋น ๋ ธ๋๊ฐ ๋ชจ๋ ๋ ธ๋์ ์ง์ ์ ์ผ๋ก ์ด์ด์ ธ์๋ค๋ฉด) ์ ์ 1, ํ์์ ์น๊ตฌ์ ์น๊ตฌ๊ฐ ์กด์ฌํ๋ค๋ฉด ์ ์2 ... ์ด๋ฐ์ฉ์ผ๋ก ๊ฐ ๊ฒฝ์ฐ ์ ์๊ฐ ์ ์ผ ์์ ํ์์ ํ์ฅ์ด๋ผ ์นญํฉ๋๋ค. ์ด ํ์ฅ์ด ๋ ์ ์๋ ํ์์ ์์ ํ์ฅ์ ์ ์, ๊ทธ๋ฆฌ๊ณ ํ์ฅ ํ๋ณด๋ค์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ถ๋ ฅํ๋ ๋ฌธ์ ์ ๋๋ค.
์ผํ ๋ณด๋ฉด ๋ณต์กํด ๋ณด์ด์ง๋ง ์ด ๋ฌธ์ ์ ํต์ฌ์ BFS - LEVEL์ ๊ตฌํ๋ ๊ฒ๋๋ค.
DFS์ ๊ฐ์ ๊ฒฝ์ฐ๋ ๋ค์ด๊ฐ ๋๋ง๋ค depth + 1์ ํ๊ณ ์ฌ๊ท๊ฐ ๋๋ ๋ depth -= 1์ ํด์ ๊น์ด๋ฅผ ์ฝ๊ฒ ๊ตฌํ ์ ์์ต๋๋ค.
๊ทธ๋ฌ๋ ์ ํฌ๊ฐ ํต์์ ์ผ๋ก BFS์ ๊น์ด๋ฅผ ๊ตฌํ ๊ฒฝ์ฐ๋ ๋ง์ง ์๊ธฐ์ ๊ด์ฐฎ์ ๋ฌธ์ ์ธ ๊ฒ ๊ฐ์ต๋๋ค.
N = int(input())
que = deque()
graph = [[0]*(N+1) for _ in range(N+1)]
visited = [0]*(N+1)
depth = -1
BFS ์ฌ์ฉ์ ์ํด que์ ๊ทธ๋ํ ๋ฐฉ๋ฌธ์ฌ๋ถ ๋ฑ์ ๋ฐ์์ค๋๋ค.
์๊ธฐ์์ ์ ๊น์ด๊ฐ 0์ด๊ธฐ ๋๋ฌธ์ ๊น์ด ์ด๊ธฐ๊ฐ์ -1๋ถํฐ ์์ํ๊ฒ ์ต๋๋ค (-1์ 1 ๋ํ๋ฉด 0์ด๋ฏ๋ก).
while True:
a,b = map(int,input().split())
graph[a][b] = graph[b][a] = 1
if a == -1 and b == -1:
break
์ ๋ ฅ๊ฐ์ด ๊ฐ๊ฐ -1,-1์ด ๋์ฌ ๋๊น์ง a์ b๋ฅผ ๋ฐ๊ณ ๊ทธ๋ํ์ ์ด์ด์ง ๋ ธ๋๋ก ํํํด์ค์๋ค.
ans = []
for i in range(1,N+1):
ans.append(bfs(i))
depth = -1
visited = [0]*(N+1)
์ด์ ๊ฐ ๋ ธ๋(ํ์)๋ง๋ค BFS๋ฅผ ๋๋ฆฐ ํ ํ๋ฒ ๋๋ ธ์ผ๋ฉด ๋ค์ ์จ๋จน์ ์ ์๊ฒ ๊น์ด์ ๋ฐฉ๋ฌธ์ฌ๋ถ๋ฅผ ์ด๊ธฐํํด์ค๋๋ค.
from collections import deque
def bfs(chairman):
global depth
que.append(chairman)
visited[chairman] = 1
deque๋ฅผ import ํ๊ณ ํ์์ ์์ํ๊ฒ ์ต๋๋ค.
์ผ๋จ ํ์ฅ์ด๋ผ ๋ณ์๋ฅผ chairman์ผ๋ก ๋๊ณ ํ์ ์ถ๊ฐํด์ค ๋ค์ ๋ค์ด์จ ์ฒซ ๋
ธ๋๋ฅผ ๋ฐฉ๋ฌธ์ฒ๋ฆฌ ํด์ฃผ์์ต๋๋ค.
while que:
์ด์ ํ๊ฐ ์ฌ๋ผ์ง ๋ ๋์ ๋๋ฆฌ๋๊ฑด ํญ์ ํ๋ ์ผ์ธ๋ฐ
for _ in range(len(que)):
์ด๊ฒ ์ด ๋ฌธ์ ์ ํต์ฌ์ ๋๋ค. ๋ค์ด์จ que์ ๊ธธ์ด๋งํผ๋ง ์ผ๋จ ๋ฐ๋ณตํด์ ํด๋น level์ ์ ์ถํด๋ด๋๋ก ํฉ์๋ค.
์๋ฅผ ๋ค์ด ๋ฃจํธ๋ ธ๋5, ํ์๋ ธ๋ 1,2,3์ด ์๋ค๋ฉด 5์ผ๋ len(que)๋ 1์ด ๋์ค๊ณ ํ๋ฒ๋ง ๋ ํ depth, ๊น์ด๋ฅผ +1 ํด์ฃผ๋ ๊ฒ๋๋ค. ๊ทธ๋ฆฌ๊ณ ๋ค์ 1,2,3์ผ๋ len(que)๋ 3์ด ๋์ค๊ณ ์ธ๋ฒ๋ง ๋ ํ depth, ๊น์ด๋ฅผ +1 ํด์ฃผ๋ ์ฉ์ผ๋ก ํ๋ฉด BFS ํ์ ์ค์์๋ ๊น์ด๋ฅผ ๊ตฌํ ์ ์์ต๋๋ค.
chairman = que.popleft()
for i in range(N+1):
if visited[i] == 0 and graph[chairman][i] == 1:
visited[i] = 1
que.append(i)
ํด๋น ๋ ธ๋์ ์ฐ๊ฒฐ๋ ๋ ธ๋๋ฅผ ํ์ํด์ ๋ฐฉ๋ฌธ์ฒ๋ฆฌํด์ฃผ๊ณ que์ ์ถ๊ฐํ์ฌ ๋ค์ ํ์์ง์ ์ผ๋ก ์ผ์ต๋๋ค.
depth += 1
return depth
๊ทธ๋ฆฌ๊ณ ๋ค์ด์จ que์ ๊ธธ์ด๋งํผ์ ๋ฐ๋ณต์ด ๋๋๋ฉด depth + 1์ ํด์ฃผ๊ณ while๋ฌธ์ผ๋ก ๋ค์ ๋ค์ด๊ฐ ํ์ ํ๋ณด ๋ ธ๋๋ค์ ํ์ํด์ค๋๋ค. ์ต์ข ์ ์ผ๋ก depth๋ฅผ return ํด์ฃผ๋ฉด ์ด ํ์์ ์น๊ตฌ ์ ์๊ฐ ๋์ต๋๋ค.
์ด ํ์ฅ์ด ๋ ์ ์๋ ํ์์ ์์ ํ์ฅ์ ์ ์, ๊ทธ๋ฆฌ๊ณ ํ์ฅ ํ๋ณด๋ค์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ถ๋ ฅํด์ผ ํฉ๋๋ค.
์๊น ans๋ผ๋ ๋ฐฐ์ด์ ํ์๋ง๋ค ์น๊ตฌ์ ์๋ฅผ ๋ค ๋ด์๋จ์ผ๋ฏ๋ก
print(min(ans),ans.count(min(ans)))
๊ฐ์ฅ ์์ ์ ์์ ๊ฐ์ฅ ์์ ์ ์๋ฅผ ๊ฐ์ง ํ์์ ์(ํ๋ณด์ ์)
for i in range(N):
if ans[i] == min(ans):
print(i+1,end=' ')
๊ทธ๋ฆฌ๊ณ ๊ฐ์ฅ ์์ ์ ์๋ฅผ ๊ฐ์ง ํ์๋ค (for๋ฌธ์ 0๋ถํฐ ์์ํ๋ฏ๋ก i+1ํ๋ฉด ํด๋น ํ์ฅํ๋ณด ์๋ก ์นํ๊ฐ๋ฅ)์ ์ถ๋ ฅํ๋ฉด ๋ฌธ์ ํด๊ฒฐ ๊ฐ๋ฅํฉ๋๋ค.