|
์ฝ๋ ์์ฑํ๊ธฐ
import heapq
def solution(N, road, K):
INF = int(1e9)
graph = [[] for _ in range(N+1)]
distance = [INF] * (N+1)
for a,b,c in road:
graph[a].append([b, c])
graph[b].append([a, c])
q = []
heapq.heappush(q,(0,1))
distance[1] = 0
while q:
dist, node = heapq.heappop(q)
if distance[node] < dist:
continue
for n,d in graph[node]:
cost = d + dist
if cost < distance[n]:
distance[n] = cost
heapq.heappush(q, (cost, n))
answer = 0
for i in range(1,N+1):
if distance[i] <= K:
answer += 1
return answer
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)๋ฅผ ์ถ๊ฐํด์ค๋ค.