๋ฌธ์
์ฌ์๊ธฐ๋ ์ํ๋์ ๊ต์ธ ๋์ฅ์์ ์จ๋ฐ๊ผญ์ง์ ํ๊ณ ์๋ค. ๋์ฅ์๋ ํ๊ฐ์ด ๋ง์ด ๋๋ ค์๊ณ ์ฌ์๊ธฐ๋ ๊ทธ ์ค์ ํ๋์ ์จ์ด์ผ ํ๋ค. ํ๊ฐ์ ๊ฐ์๋ N(2 <= N <= 20,000)๊ฐ์ด๋ฉฐ, 1 ๋ถํฐ ์๋ค๊ณ ํ์.
์ฌ์๊ธฐ๋ ์ํ๋๊ฐ 1๋ฒ ํ๊ฐ๋ถํฐ ์ฐพ์ ๊ฒ์ ์๊ณ ์๋ค. ๋ชจ๋ ํ๊ฐ์ M(1<= M <= 50,000)๊ฐ์ ์๋ฐฉํฅ ๊ธธ๋ก ์ด์ด์ ธ ์๊ณ , ๊ทธ ์ ๋์ A_i ์ B_i(1<= A_i <= N; 1 <= B_i <= N; A_i != B_i)๋ก ๋ํ๋ธ๋ค. ๋ํ ์ด๋ค ํ๊ฐ์์ ๋ค๋ฅธ ํ๊ฐ์ผ๋ก๋ ์ธ์ ๋ ๋๋ฌ ๊ฐ๋ฅํ๋ค๊ณ ์๊ฐํด๋ ์ข๋ค.
์ฌ์๊ธฐ๋ ๋ฐ๋์๊ฐ ์ง๋ ํ๊ธฐ ๋๋ฌธ์ ์ต๋ํ ๋์๊ฐ ์๋๊ฒ ์จ์ ์ฅ์๋ฅผ ์ฐพ๊ณ ์ ํ๋ค. ๋์๋ 1๋ฒ ํ๊ฐ์์์ ๊ฑฐ๋ฆฌ(์ฌ๊ธฐ์ ๊ฑฐ๋ฆฌ๋ผ ํจ์ ์ง๋์ผ ํ๋ ๊ธธ์ ์ต์ ๊ฐ์์ด๋ค)๊ฐ ๋ฉ์ด์ง์๋ก ๊ฐ์ํ๋ค๊ณ ํ๋ค. ์ฌ์๊ธฐ์ ๋ฐ๋์๋ฅผ ์ต๋ํ ์จ๊ธธ ์ ์๋ ํ๊ฐ์ ์ฐพ์ ์ ์๊ฒ ๋์์ฃผ์!
์ ๋ ฅ
์ฒซ ๋ฒ์งธ ์ค์๋ N๊ณผ M์ด ๊ณต๋ฐฑ์ ์ฌ์ด์ ๋๊ณ ์ฃผ์ด์ง๋ค.
์ดํ M์ค์ ๊ฑธ์ณ์ A_i์ B_i๊ฐ ๊ณต๋ฐฑ์ ์ฌ์ด์ ๋๊ณ ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ถ๋ ฅ์ ํ์ค๋ก ์ด๋ฃจ์ด์ง๋ฉฐ, ์ธ ๊ฐ์ ๊ฐ์ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ์ง์ด ์ถ๋ ฅํด์ผํ๋ค.
์ฒซ ๋ฒ์งธ๋ ์จ์ด์ผ ํ๋ ํ๊ฐ ๋ฒํธ๋ฅผ(๋ง์ฝ ๊ฑฐ๋ฆฌ๊ฐ ๊ฐ์ ํ๊ฐ์ด ์ฌ๋ฌ๊ฐ๋ฉด ๊ฐ์ฅ ์์ ํ๊ฐ ๋ฒํธ๋ฅผ ์ถ๋ ฅํ๋ค), ๋ ๋ฒ์งธ๋ ๊ทธ ํ๊ฐ๊น์ง์ ๊ฑฐ๋ฆฌ๋ฅผ, ์ธ ๋ฒ์งธ๋ ๊ทธ ํ๊ฐ๊ณผ ๊ฐ์ ๊ฑฐ๋ฆฌ๋ฅผ ๊ฐ๋ ํ๊ฐ์ ๊ฐ์๋ฅผ ์ถ๋ ฅํด์ผํ๋ค.
์ ๋ต
import heapq
import sys
input = sys.stdin.readline
INF = 1e9
n, m = map(int, input().split())
graph = [[] for _ in range(n+1)]
distance = [INF] * (n+1)
for _ in range(m):
a, b = map(int, input().split())
graph[a].append((b, 1))
graph[b].append((a, 1))
def dijkstra(start):
q = []
heapq.heappush(q, (0, start))
distance[start] = 0
while q:
dist, now = heapq.heappop(q)
if distance[now] < dist:
continue
for i in graph[now]:
cost = dist + i[1]
if cost < distance[i[0]]:
distance[i[0]] = cost
heapq.heappush(q, (cost, i[0]))
dijkstra(1)
max_node = 0
max_dist = 0
res = 0
for i in range(1, n+1):
if max_dist < distance[i]:
max_dist = distance[i]
max_node = i
res = distance.count(max_dist)
print(max_node, max_dist, res
๋ค์ต์คํธ๋ผ ์ด์ฉํด์ ํ
'Algorithm > Python' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Python] ๋ฐฑ์ค 1613 - ์ญ์ฌ (1) | 2023.02.05 |
---|---|
[Python] ๊ทธ๋ํ ์๊ณ ๋ฆฌ์ฆ - ์น๊ตฌ์ ์น๊ตฌ์ฐพ๊ธฐ (1) | 2020.09.07 |
[Python] ํ์ ์คํ(queue, stack) (0) | 2020.08.31 |
[Python] ์ด๋ถ ํ์ (0) | 2020.08.26 |
[Python] ํต ์ ๋ ฌ (0) | 2020.08.25 |