๐ฑ ์ต๋จ ๊ฒฝ๋ก ์๊ณ ๋ฆฌ์ฆ
์ต๋จ ๊ฒฝ๋ก ์๊ณ ๋ฆฌ์ฆ(Shortestest Path)์ ๊ฐ์ฅ ์ ์ ๋น์ฉ(Minimum Cost)์ผ๋ก ์ฐ๊ฒฐํ๋ ๊ฐ์ ๋ค์ ์ฐพ๋ ๋ฌธ์ ์ ๋๋ค.
๋ํ์ ์ธ ์ต๋จ ๊ฒฝ๋ก ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ก, ๋ค์ต์คํธ๋ผ, ๋ฒจ๋ง-ํฌํธ, ํ๋ก์ด๋-์์ , A* ์๊ณ ๋ฆฌ์ฆ์ด ์์ต๋๋ค.
์ด๋ฒ ํฌ์คํ ์์๋ ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ(Dijkstra) ์์ฃผ๋ก ๊ณต๋ถํด๋ณผ ์์ ์ ๋๋ค.
๐ ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ ๊ตฌํํ๊ธฐ
๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ์ ์์๋ ธ๋์์๋ถํฐ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ๊ตฌํ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค.
์ฒซ๋ฒ์งธ ๋ฌธ์ ๋ ํน์ ๋ ธ๋์์ ๋ชจ๋ ๋ ธ๋์ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ์ฐพ๋ ํ๋ก๊ทธ๋๋จธ์ค - ๋ฐฐ๋ฌโ ๋ฌธ์ ์ ๋๋ค. ๋ฌธ์ ๋ฅผ ํตํด ๋์ ๋ฐฉ์์ ์ดํดํด๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
ํด๋น ๋ฌธ์ ๋ 1๋ฒ ๋ ธ๋๋ถํฐ 5๋ฒ ๋ ธ๋๊น์ง์ ๊ฐ์ ๊ณผ ์ฐ๊ฒฐ๋ ๋ ธ๋๊ฐ ๋ด๊ธด ๋ฆฌ์คํธ `road`์ ๋ ธ๋์ ๊ฐฏ์ `N` ์ ํ ๊ฒฝ๋ก `K`๊ฐ ์ฃผ์ด์ง๋ฉด ์ ํ ๊ฒฝ๋ก ์์ ์๋ ์ต๋จ ๊ฒฝ๋ก์ ๋ ธ๋์ ๊ฐฏ์๋ฅผ ์ฐพ๋ ๋ฌธ์ ์ ๋๋ค.
1. ๋จผ์ ๋น์ฉ ๋ฆฌ์คํธ ๋ง๋ค๊ธฐ
์ต๋จ ๊ฒฝ๋ก ๋ฌธ์ ์ ํฌ์ธํธ๋ ๋จผ์ ๋ฐฉ๋ฌธ์ฌ๋ถ์ ๋น์ฉ(Cost; Distance)๋ฅผ ํ์ธ๋ฅผ ํ์ธํ๋ ๋ฆฌ์คํธ๊ฐ ํ์ํ๋ค๋ ๊ฒ์ ๋๋ค.
์๋์ ๊ฐ์ด ๋น์ฉ์ ๊ณ์ฐํ๋ ๋ฆฌ์คํธ๋ฅผ ๋ง๋ค๊ณ ์์ ๋ ธ๋์ 0์ผ๋ก ๋์ ํ๊ณ ๋๋จธ์ง์ ์ต๋๊ฐ์ธ `1e9` or (`float('inf')`)๋ฅผ ๋ฃ์์ต๋๋ค.
def solution(N, road, K):
dist = [1e9] * (N+1)
dist[1] = 0
graph = [[] for _ in range(N+1)]
for r in road:
graph[r[0]].append([r[2], r[1]])
graph[r[1]].append([r[2], r[0]])
dijkstra(dist,graph)
# ๊ฑฐ๋ฆฌ ์ค K ์ดํ์ ๋
ธ๋์ ๊ฐฏ์ ๋ฐํํ๊ธฐ
return len([i for i in dist if i <= K])
2. ๋ฐฉ๋ฌธ์ ์ํด ์ฐ์ ์์ ํ์ฌ์ฉํ๊ธฐ
๋๋์ด, ์ง๊ธ๋ถํฐ ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ์ ์ ์ฉํ๋ ์ผ์ ๋๋ค.
๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ์ ์ฐ์ ์์ ํ๋ฅผ ์ด์ฉํด ๊ฐ์ฅ ๊ฑฐ๋ฆฌ๊ฐ ์์ ๊ฐ๋ถํฐ ์ถ์ถํด์ผ ํฉ๋๋ค.
์ฐ์ ์์ ํ์ ๋ํ ์ ๋ณด๋ ์ฐ์ ์์ ํ ํฌ์คํธโ์ ์ ๋ฆฌํด๋์์ต๋๋ค. ํ์ด์ฌ์์๋ `heapq` ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ฉด ์ฝ๊ฒ ๊ตฌํํ ์ ์์ต๋๋ค.
- ๋จผ์ ์ฐ์ ์์ ํ๋ฅผ ํตํด ๊ฐ์ฅ ๋น์ฉ์ด ์ ์ ์ ์ ์ ๊บผ๋ด ํ์ฌ ์ ์ (`node`)์ผ๋ก ์ค์ ํฉ๋๋ค. (์ฒ์์ 1๋ฒ ๋ ธ๋๊ฐ ํ์ฌ ์ ์ ์ผ ๊ฒ์ ๋๋ค.)
- ํ์ฌ ์ ์ ๊ณผ ์ธ์ ํ ์ ์ ๋ค์ cost ๊ฐ์ ๋น๊ตํ๋ฉด์ ์ต์๊ฐ์ ๊ฐฑ์ ํ๊ฒ ๋ฉ๋๋ค. (`cost + next_cost < dist[next_node]`)
- ๊ทธ ๋ค์, ๊ฐฑ์ ์ด ๋์๋ค๋ฉด ๊ฐฑ์ ๋ ๋ ธ๋(`next_node`)์ ๊ฐฑ์ ๊ฐ์ ๋ฃ์ด์ฃผ๊ณ ๋ค์ ํ์ ์ถ๊ฐํด์ฃผ๋ฉด ๋ฉ๋๋ค.
import heapq
def dijkstra(distance, graph):
# ๋ฐฉ๋ฌธํ ๋
ธ๋๊ฐ ์ ์ฅ๋ ์ฐ์ ์์ ํ
queue = []
heapq.heappush(queue, [0, 1]) # ์์ ๋
ธ๋๋ถํฐ ์์
while queue:
cost, node = heapq.heappop(queue) # 1
# ์ด๋ฏธ ๋ฐฉ๋ฌธํ ์ ์ ์ ๊ฒฝ์ฐ
if distance[node] == 1e9:
continue
for next_cost, next_node in graph[node]:
if cost + next_cost < dist[next_node]: # 2
distance[next_node] = cost + next_cost # 2
heapq.heappush(queue, [cost + next_cost, next_node]) # 3
๐ฑ ์๊ฐ ๋ณต์ก๋
๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ 1๊ฐ์ ๋ ธ๋์์ ์ธ์ ํ ๊ฐ์ ๋ค์ ๋ชจ๋ ๊ฒ์ฌํ๊ฒ๋ฉ๋๋ค.
๋, ๊ฐ์ ์ ๊ฒ์ฌํ ๋๋ง๋ค ์ฐ์ ์์ ํ๋ฅผ ํตํด ๋ ธ๋ ๋ฐ ๊ฑฐ๋ฆฌ๋ฅผ ์ถ๊ฐํ๋ ๊ณผ์ ์ด ์์ต๋๋ค.
๊ฒฐ๋ก ์ ์ผ๋ก, ๊ฐ์ ์ ๋ชจ๋ ๊ฒ์ฌํ๋ ๊ณผ์ (`O(E)`)์ ๊ฑฐ๋ฆฌ ์ ๋ณด๋ฅผ ์ถ๊ฐํ๋ ๊ณผ์ (`O(log V)`)์ ํฉ์น ์๊ฐ ๋ณต์ก๋ ์ ๋๋ค.
์๊ฐ ๋ณต์ก๋ |
O(E log V) |
๐ฑ ์ด์ธ ์ต๋จ ๊ฒฝ๋ก ์๊ณ ๋ฆฌ์ฆ
์ต๋จ ๊ฒฝ๋ก ์๊ณ ๋ฆฌ์ฆ์ผ๋ก๋ ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ๋ง ์๋ ๊ฒ์ด ์๋๋๋ค. ์ด์ธ์๋ ํ๋ก์ด๋-์์ ์๊ณ ๋ฆฌ์ฆ, A* ์๊ณ ๋ฆฌ์ฆ์ด ์์ต๋๋ค.
- ํ๋ก์ด๋ ์์ ์๊ณ ๋ฆฌ์ฆ : 3์ค ๋ฐ๋ณต๋ฌธ์ ์ด์ฉํด ๋ชจ๋ ๋ ธ๋์ ์ต๋จ ๊ฑฐ๋ฆฌ๋ฅผ ๊ตฌํ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค.
- A* ์๊ณ ๋ฆฌ์ฆ : ํด๋ฆฌ์คํฑ ํจ์(ํ๊ฐ ํจ์)๋ฅผ ํตํด ์ถ์ ๊ฑฐ๋ฆฌ๋ฅผ ๊ณ์ฐํ๋ ์๊ณ ๋ฆฌ์ฆ ์ ๋๋ค. ์๊ฐ ๋ณต์ก๋๋ ํด๋ฆฌ์คํฑ ํจ์์ ๋ฐ๋ผ ๋ฌ๋ผ์ง์ง๋ง ์ต์ O(E)์ ์๊ฐ์ ๋์ํฉ๋๋ค.
- ๋ฒจ๋ง ํฌ๋ ์๊ณ ๋ฆฌ์ฆ : ์์ ๊ฐ์ค์น๊ฐ ์๋ ๊ทธ๋ํ์์๋ ์ฌ์ฉ๋ ์ ์๋ค๋ ํน์ง์ด ์์ต๋๋ค. ๊ทธ๋ฌ๋ฏ๋ก ์๊ฐ ๋ณต์ก๋๋ O(V * E) ์ ๋๋ค.
๐ ํ์ด๋ณด๊ธฐ ์ข์ ๋ฌธ์ ๋ค
โ๏ธ ํฌ์คํ ์ด ๋์์ด ๋์๋ ์๋ฃ
- EBS ๋งํฌ ์ํํธ์จ์ด ์ธ์, "๊ฐ์ฅ ๋น ๋ฅธ ๊ธธ์ ์ฐพ์๋ผ, ์ต๋จ ๊ฒฝ๋ก ์๊ณ ๋ฆฌ์ฆ"
- ๋ฐฐ๋ฌ์~ ๋ฐฐ๋ฌ ๊ฐ๋ ๊ธธ ์๋ ค์ค!(๋จํธํจ) - ์ฐ์ํ๊ธฐ์ ๋ธ๋ก๊ทธ
์ค๋๋ ์ ์ ํฌ์คํธ๋ฅผ ์ฝ์ด์ฃผ์ ์ ๊ฐ์ฌํฉ๋๋ค.
์ค๋ช ์ด ๋ถ์กฑํ๊ฑฐ๋ ์ดํดํ๊ธฐ ์ด๋ ต๊ฑฐ๋ ์๋ชป๋ ๋ถ๋ถ์ด ์์ผ๋ฉด ๋ถ๋ด์์ด ๋๊ธ๋ก ๋จ๊ฒจ์ฃผ์๋ฉด ๊ฐ์ฌํ๊ฒ ์ต๋๋ค.
'Algorithm Study' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋ฐฑํธ๋ํน(BackTracking) (0) | 2024.04.16 |
---|---|
DFS, BFS ๊ทธ๋ํ ํ์ ์๊ณ ๋ฆฌ์ฆ 1 (0) | 2024.03.21 |
ํธ๋ฆฌ ์ํ ์๊ณ ๋ฆฌ์ฆ (0) | 2024.03.14 |
[์ฝํ ์คํฐ๋] ์ ๋ ฌ (0) | 2024.03.11 |
์ฐ์ ์์ ํ์ ํ์ ์ฐจ์ด๋ฅผ ์์๋ณด์. (2) | 2024.02.24 |