[BOJ][๐ก5][๋ฐฑ์ค#02660] ํ์ฅ๋ฝ๊ธฐ
์์ฑ:    
์ ๋ฐ์ดํธ:
์นดํ ๊ณ ๋ฆฌ: BOJ Gold V
๋ฌธ์ ์ถ์ฒ
๋ฌธ์
์๋์ปต ์ถ๊ตฌ์ ์์์ ์ํ ๋ชจ์์์ ํ์ฅ์ ์ ์ถํ๋ ค๊ณ ํ๋ค. ์ด ๋ชจ์์ ๋ง๋ค์ด์ง์ง ์ผ๋ง ๋์ง ์์๊ธฐ ๋๋ฌธ์ ํ์ ์ฌ์ด์ ์๋ก ๋ชจ๋ฅด๋ ์ฌ๋๋ ์์ง๋ง, ๋ช ์ฌ๋์ ํตํ๋ฉด ๋ชจ๋๊ฐ ์๋ก ์ ์ ์๋ค. ๊ฐ ํ์์ ๋ค๋ฅธ ํ์๋ค๊ณผ ๊ฐ๊น์ด ์ ๋์ ๋ฐ๋ผ ์ ์๋ฅผ ๋ฐ๊ฒ ๋๋ค. ์๋ฅผ ๋ค์ด ์ด๋ ํ์์ด ๋ค๋ฅธ ๋ชจ๋ ํ์๊ณผ ์น๊ตฌ์ด๋ฉด, ์ด ํ์์ ์ ์๋ 1์ ์ด๋ค. ์ด๋ ํ์์ ์ ์๊ฐ 2์ ์ด๋ฉด, ๋ค๋ฅธ ๋ชจ๋ ํ์์ด ์น๊ตฌ์ด๊ฑฐ๋ ์น๊ตฌ์ ์น๊ตฌ์์ ๋งํ๋ค. ๋ํ ์ด๋ ํ์์ ์ ์๊ฐ 3์ ์ด๋ฉด, ๋ค๋ฅธ ๋ชจ๋ ํ์์ด ์น๊ตฌ์ด๊ฑฐ๋, ์น๊ตฌ์ ์น๊ตฌ์ด๊ฑฐ๋, ์น๊ตฌ์ ์น๊ตฌ์ ์น๊ตฌ์์ ๋งํ๋ค. 4์ , 5์ ๋ฑ์ ๊ฐ์ ๋ฐฉ๋ฒ์ผ๋ก ์ ํด์ง๋ค. ๊ฐ ํ์์ ์ ์๋ฅผ ์ ํ ๋ ์ฃผ์ํ ์ ์ ์ด๋ค ๋ ํ์์ด ์น๊ตฌ์ฌ์ด์ด๋ฉด์ ๋์์ ์น๊ตฌ์ ์น๊ตฌ์ฌ์ด์ด๋ฉด, ์ด ๋์ฌ๋์ ์น๊ตฌ์ฌ์ด๋ผ๊ณ ๋ณธ๋ค. ํ์ฅ์ ํ์๋ค ์ค์์ ์ ์๊ฐ ๊ฐ์ฅ ์์ ์ฌ๋์ด ๋๋ค. ํ์ฅ์ ์ ์์ ํ์ฅ์ด ๋ ์ ์๋ ๋ชจ๋ ์ฌ๋์ ์ฐพ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ ๋ ฅ์ ์ฒซ์งธ ์ค์๋ ํ์์ ์๊ฐ ์๋ค. ๋จ, ํ์์ ์๋ 50๋ช ์ ๋์ง ์๋๋ค. ๋์งธ ์ค ์ดํ๋ก๋ ํ ์ค์ ๋ ๊ฐ์ ํ์๋ฒํธ๊ฐ ์๋๋ฐ, ์ด๊ฒ์ ๋ ํ์์ด ์๋ก ์น๊ตฌ์์ ๋ํ๋ธ๋ค. ํ์๋ฒํธ๋ 1๋ถํฐ ํ์์ ์๋งํผ ๋ถ์ด ์๋ค. ๋ง์ง๋ง ์ค์๋ -1์ด ๋ ๊ฐ ๋ค์ด์๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์๋ ํ์ฅ ํ๋ณด์ ์ ์์ ํ๋ณด์ ์๋ฅผ ์ถ๋ ฅํ๊ณ , ๋ ๋ฒ์งธ ์ค์๋ ํ์ฅ ํ๋ณด๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ๋ชจ๋ ์ถ๋ ฅํ๋ค.
์์
์ ๋ ฅ
5
1 2
2 3
3 4
4 5
2 4
5 3
-1 -1
์ถ๋ ฅ
2 3
2 3 4
My Sol
from collections import deque
def BFS(i):
Q = deque()
Q.append(i)
visited = [0]*(V+1)
visited[i] = 1
dis = -1
while Q and (dis <= minV):
for _ in range(len(Q)):
s = Q.popleft()
visited[s] = 1
for v in rel[s]:
if visited[v]: continue
visited[v] = 1
Q.append(v)
dis += 1
return dis
V = int(input())
rel = [[] for _ in range(V+1)]
while True:
u, v = map(int, input().split())
if u==v==-1: break
rel[u].append(v)
rel[v].append(u)
minV = 50
candis = []
for i in range(1, V+1):
ret = BFS(i)
if minV > ret:
candis = [i]
minV = ret
elif minV==ret:
candis.append(i)
print(minV, len(candis))
print(*sorted(candis))
1๋ฒ๋ถํฐ V๋ฒ๊น์ง ๊ฐ ์ฌ๋์ ๋ํ์ฌ ์ผ๋ง๋ ์งง์ ๊ด๊ณ๋ง์ ์ ์ฒด ์ง๋จ์ ์ ์ ์๋์ง ๊ทธ ์ต๋จ๊ฑฐ๋ฆฌ๋ฅผ ์ฐพ๋ ๋ฌธ์ ์๋ค. deque์ BFS๋ฅผ ์ด์ฉํ์๋ค. ์ ๋ ฅ๋ ๋ ์๊ฐ -1์ผ ๋๊น์ง ๊ด๊ณ์ ๋ํ ์ ๋ ฅ์ ๋ฐ์ ์ฒ๋ฆฌํด์ค๋ค.
์ธ์ ๊ทธ๋ํ์ ์ธ์ ๋ฆฌ์คํธ๋ฅผ ์ฌ์ฉํ ์ ์๋๋ฐ, ์๊ฐ ์ ์ด์ ๋ฆฌ์คํธ๋ฅผ ์ฌ์ฉํ์๋ค. ์ฌ๋์ ๋ฒํธ์ ํด๋นํ๋ ์ธ๋ฑ์ค๋ฅผ ์ฌ์ฉํ๋๋ก ์ฌ๋ ์๋ณด๋ค 1๊ฐ ๋ ๋ง๊ฒ ๋น ๋ฆฌ์คํธ๋ก ์ด๊ธฐํํ์๊ณ , ์ฌ๊ธฐ์ ๊ด๊ณ๋๋ ์ฌ๋์ ๋ฒํธ๋ฅผ ์ ๋ ฅํด ๋ฃ๋ ๊ฒ์ด๋ค.
๊ทธ๋ฆฌ๊ณ ๊ฐ ํ๋ณด๋ง๋ค ์ ์ฒด๋ฅผ ์๋, ์ฆ Q๊ฐ ๋น ๋๊น์ง ์ผ๋ง๋งํผ for๋ฌธ์ ๋ฐ๋ณตํด์ผํ๋์ง ์ฒดํฌํด์ ๋ฐํํ๋๋ฐ, ์ด ๋ฐํ๊ฐ์ด ์ ์ญ๋ณ์ minV๋ณด๋ค ์๋ค๋ฉด ๊ฐ์ฅ ์งง์ ํ์๋ง์ ์ ์ฒด๋ฅผ ์๋ ๋ฐ์ ๋๋ฌํ ํ๋ณด์ด๋ฏ๋ก ๋จ๋ ํ๋ณด๊ฐ ๋์ง๋ง, minV์ ๊ฐ๋ค๋ฉด ๋จ๋ ํ๋ณด์ ์ ์ฒด๋ฅผ ์๋ ๋ฐ์ ๋๋ฌํ ํ์๊ฐ ๊ฐ์ผ๋ฏ๋ก ํ๋ณด ๋ชฉ๋ก์ ์ถ๊ฐํด์ค๋ค. ์ด๋ฅผ ๋๊น์ง ๋ฐ๋ณตํ์ฌ ํ๋ณด ๋ชฉ๋ก์ ์์ ํ์๋ฅผ ๊ตฌํ ์ ์์๋ค.
๊ฒฐ๊ณผ
๋ง์์ต๋๋ค!!
๋ชจ๋ฒ๋ต์
N = int(input())
graph = [[] for _ in range(N+1)]
visit = [[0] for _ in range(N+1)]
while True:
a, b = map(int,input().split())
if a == -1 and b == -1: break;
graph[a].append(b)
graph[b].append(a)
def BFS(c):
q = [c]
visit = [-1]*(N+1)
visit[c] = 0
while q:
n = q.pop(0)
for g in graph[n]:
if visit[g]==-1:
q.append(g)
visit[g] = visit[n] + 1
return max(visit)
ans = []
for i in range(1,N+1):
ans.append(BFS(i))
min_v = min(ans)
print(min_v, ans.count(min_v))
for i in range(N):
if min_v == ans[i]:
print(i+1,end=' ')
BFS ๊ณผ์ ์ด ๋์์ด ๋ ๊ฒ ๊ฐ์ ๊ฐ์ ธ์จ ํ์ด์ด๋ค. visited ๋ฐฐ์ด ์์ฒด์ ๊ด๊ณ๊น์ง ๋๋ฌํ๊ธฐ ์ํ ํ์๋ฅผ ์ธ์ด ํ์ํ์๊ณ , ๋ชจ๋ ์กฐํ๊ฐ ๋๋๋ฉด ์ด visited ๋ฐฐ์ด์์ ๊ฐ์ฅ ํฐ ๊ฐ์ ๋ฐํํ๋ค. ์ด ๊ฐ๊ฐ์ ๋ชจ๋ ans์ ๋ฃ์ด ๋ชจ๋ ์ฌ๋์ ๋ํ ํ์ ์กฐํ๊ฐ ๋๋๋ฉด ans ๋ฐฐ์ด์์ ๊ฐ์ฅ ์์ ๊ฐ์ ์ฐพ์ ์ด๋ฅผ ๊ฐ์ง ์ธ๋ฑ์ค ๋ฒํธ๋ค์ ํตํด ํ๋ณด ๋ฒํธ๋ฅผ ์ถ๋ ฅํ๊ณ , count()๋ฅผ ํด์ ํ๋ณด์ ์, ๊ทธ๋ฆฌ๊ณ ํ์๋ฅผ ์ถ๋ ฅํ๋ ๋ฐฉ์์ด๋ค.
๋๊ธ๋จ๊ธฐ๊ธฐ