|
์ฝ๋ ์์ฑํ๊ธฐ
import heapq
def dijkstra(start, graph, distance):
q = []
heapq.heappush(q,(0, start))
distance[start] = 0
while q:
dist, node = heapq.heappop(q)
if distance[node] < dist:
continue
for x in graph[node]:
cost = dist + x[1]
if cost < distance[x[0]]:
distance[x[0]] = cost
heapq.heappush(q, (cost, x[0]))
def solution(n, edge):
INF = int(1e9)
graph = [[] for _ in range(n+1)]
distance = [INF] * (n+1)
for a,b in edge:
graph[a].append((b,1))
graph[b].append((a,1))
dijkstra(1, graph, distance)
long_distance = max(distance[1:])
print(distance)
return distance.count(long_distance)
Python
๋ณต์ฌ
|
์ฝ๋ ์ค๋ช
ํ๊ธฐ
์ต๋จ๊ฒฝ๋ก ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ์ด๋ฏ๋ก ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ์ ์ด์ฉํ์ฌ ํ์ดํ ์ ์์๋ค.
1.
graph์ distance๋ฅผ ๊ฐ๊ฐ N+1๋งํผ ์ด๊ธฐํํ๋ค.
graph๋ฅผ ํํํ๋ ๋ฐฉ๋ฒ์๋ ํฌ๊ฒ ์ธ์ ํ๋ ฌ๊ณผ ์ธ์ ๋ฆฌ์คํธ ์ด๋ ๊ฒ 2๊ฐ์ง๊ฐ ์๋๋ฐ, ์ฌ๊ธฐ์๋ ์ธ์ ๋ฆฌ์คํธ๋ฅผ ์ฌ์ฉํ์ฌ ๊ทธ๋ํ๋ฅผ ํํํ์๋ค.
distance๋ 1๋ฒ ๋
ธ๋๋ถํฐ ๊ฐ ๋
ธ๋๊น์ง์ ๊ฑฐ๋ฆฌ๋ฅผ ์ ์ฅํ ๋ฐฐ์ด๋ก INF(๋ฌดํ)์ผ๋ก ์ด๊ธฐํํ๋ค.
N+1๊ฐ๋ฅผ ์์ฑํ๋ ์ด์ ๋ ๋
ธ๋๋ฒํธ๊ฐ 1๋ถํฐ ์์ํ๊ธฐ ๋๋ฌธ์ ๋ค์์ ์ข ๋ ๊ฐ๋
์ฑ ์ข์ ์ฝ๋๋ฅผ ์ฐ๊ธฐ ์ํด์์ด๋ค. ๊ทธ๋์ 0๋ฒ์งธ ๋ฐฐ์ด์ ์ฌ์ฉ๋์ง ์๋๋ค.
2.
์ฐ์ ์์ ํ๋ฅผ ์ ์ธํ๊ณ (์์๋
ธ๋์ ๊ฑฐ๋ฆฌ, ์์๋
ธ๋)๋ฅผ ํ์ ๋ฃ์ด์ค๋ค.
๋งค ๋จ๊ณ๋ง๋ค ๋ฐฉ๋ฌธํ์ง ์์ ๋
ธ๋ ์ค์์ ๊ฐ์ฅ ๊ฑฐ๋ฆฌ๊ฐ ์งง์ ๋
ธ๋๋ฅผ ์ ํํด์ผ ๋๊ธฐ ๋๋ฌธ์ ์ฐ์ ์์ ํ๋ฅผ ์ฌ์ฉํ๋ค. ์ด ๋, ์ฐ์ ์์์ ๊ธฐ์ค์ ํํ์ 0๋ฒ์งธ ์ธ๋ฑ์ค(=๊ฑฐ๋ฆฌ)์ด๋ค.
3.
ํ๊ฐ ๋น๋๊น์ง ๋ค์์ ๋ฐ๋ณตํ๋ค.
a.
ํ์์ ๊ฐ์ฅ ๊ฑฐ๋ฆฌ๊ฐ ์งง์ ๋
ธ๋(node)๋ฅผ ๋ฝ๋๋ค.
b.
๋ง์ฝ ํ์ฌ ๊ฑฐ๋ฆฌ ๋ฆฌ์คํธ(distance)์์ ํด๋น ๋
ธ๋์ ๊ฑฐ๋ฆฌ(distance[node])๊ฐ ๋ฝ์ ๋
ธ๋์ ๊ฑฐ๋ฆฌ(dist)๋ณด๋ค ๋ ์๋ค๋ฉด ์ด๋ฏธ ๋ฐฉ๋ฌธํ๋ค๋ ์๋ฏธ์ด๋ฏ๋ก ์๋๋ฅผ ์ํํ์ง ์๊ณ ๋์ด๊ฐ๋ค.
c.
๋ฝ์ ๋
ธ๋์ ์ธ์ ํ๊ฒ ์ฐ๊ฒฐ๋ ๋
ธ๋๋ค์ for๋ฌธ์ ๋๋ฉด์ ์ํํ๋ค.
i.
ํ์ฌ ๋
ธ๋(node)๋ฅผ ๊ฑฐ์ณ์ ๊ฐ๋ ๊ฒฝ์ฐ์ ๊ฑฐ๋ฆฌ๋ฅผ ๊ณ์ฐํ์ฌ cost์ ์ ์ฅํ๋ค.
ii.
๋ง์ฝ, ํ์ฌ ๊ฑฐ๋ฆฌ ๋ฆฌ์คํธ(distance)๋ณด๋ค cost๊ฐ ์๋ค๋ฉด ๊ฑฐ๋ฆฌ ๋ฆฌ์คํธ๋ฅผ ์
๋ฐ์ดํธ ํด์ฃผ๊ณ , ํ์ (cost, n)๋ฅผ ์ถ๊ฐํด์ค๋ค.
4.
distance์์ ์ต๋๊ฐ์ ์ฐพ๊ณ countํจ์๋ฅผ ์ฌ์ฉํ์ฌ ์ต๋๊ฐ์ด ๋ช ๊ฐ์ธ์ง ์ฐพ๋๋ค.