Dijkstra Algorithm
1. ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ์ด๋?
๊ทธ๋ํ์์ ํ๋์ ์์ ์ ์ ์ผ๋ก๋ถํฐ ๋ค๋ฅธ ๋ชจ๋ ์ ์ ๊น์ง์ ์ต๋จ ๊ฒฝ๋ก(Shortest Path) ๋ฅผ ๊ตฌํ๋ ์๊ณ ๋ฆฌ์ฆ.
๋จ, ๋ชจ๋ ๊ฐ์ ์ ๊ฐ์ค์น๊ฐ 0 ๋๋ ์์ ์ฌ์ผํจ. (์์ ๊ฐ์ค์น X)
ํต์ฌ ๊ฐ๋
:
๋งค๋ฒ ๊ฐ์ฅ ๊ฐ๊น์ด ๋ ธ๋ ๋ฅผ ์ ํํด์, ๊ทธ ๋ ธ๋๋ฅผ ํตํด ๋ค๋ฅธ ๋ ธ๋๋ก ๊ฐ๋ ๋ ์งง์ ๊ฒฝ๋ก๊ฐ ์๋์ง ๊ฐฑ์ ํจ.
๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ ์ ์ผ์ข (ํ ๋ฒ ์ ํํ ๋ ธ๋๋ ๋ค์ ์ฒ๋ฆฌํ์ง ์์)
2. ๋์ ๋ฐฉ์(์ฐ์ ์์ ํ ์ฌ์ฉ ๋ฒ์ )
์ถ๋ฐ ๋ ธ๋๋ฅผ ๊ธฐ์ค์ผ๋ก ๊ฑฐ๋ฆฌ ๋ฐฐ์ด
dist[]
๋ฅผ ์ด๊ธฐํ (dist[start] = 0
, ๋๋จธ์ง๋INF
)PriorityQueue
๋ฅผ ์ด์ฉํด ๊ฐ์ฅ ๊ฐ๊น์ด ๋ ธ๋๋ฅผ ๊ณ์ ์ ํํด๋น ๋ ธ๋๋ฅผ ํตํด ๋ค๋ฅธ ๋ ธ๋๋ก ๊ฐ๋ ๊ฑฐ๋ฆฌ๋ฅผ ๊ฐฑ์
๋ชจ๋ ๋ ธ๋๋ฅผ ์ฒ๋ฆฌํ ๋๊น์ง ๋ฐ๋ณต
3. ์๋ฐ ๊ตฌํ (์ฐ์ ์์ ํ ๊ธฐ๋ฐ)
Class Edge implements Comparable<Edge> {
int to, weight;
Edge(int to, int weight) {
this.to = to;
this.weight = weight;
}
public int compareTo(Edge other) {
return this.weight - other.weight;
}
}
public void dijkstra(int start, List<List<Edge>> graph, int[] dist) {
int n = graph.size();
boolean[] visited = new boolean[n];
Arrays.fill(dist, Integer.MAX_VALUE);
dist[start] = 0;
PriorityQueue<Edge> pq = new PriorityQueue<>();
pq.offer(new Edge(start, 0));
while(!pq.isEmpty()) {
Edge current = pq.poll();
int curNode = current.to;
if(visited[curNode]) continue;
visited[curNode] = true;
for(Edge e : graph.get(curNode)) {
int next = e.to;
int cost = dist[curNode] + e.weight;
if(cost < dist[next]) {
dist[next] = cost;
pq.offer(new Edge(next, cost));
}
}
}
}
๊ทธ๋ํ ์ค๋น(์ธ์ ๋ฆฌ์คํธ)
List<List<Edge>> graph = new ArrayList<>();
for(int i = 0; i <= N; i++) {
graph.add(new ArrayList<>());
}
graph.get(1).add(new Edge(2, 4));
graph.get(1).add(new Edge(3, 2));
graph.get(2).add(new Edge(3, 5));
// ๋ฑ๋ฑ ...
4. ์๊ฐ ๋ณต์ก๋
๋ฐฐ์ด ์ฌ์ฉ
O(Vยฒ)
์์ ์ ์ ์์์ ์ฌ์ฉ (V โค 500)
์ฐ์ ์์ ํ
O((V + E) log V)
๋ณดํต์ Dijkstra ๊ตฌํ
ํ + ์ธ์ ๋ฆฌ์คํธ
O(E log V)
ํฌ์ ๊ทธ๋ํ์์ ํจ์จ์
5. ์ฌ์ฉ ์กฐ๊ฑด ์ ๋ฆฌ
๊ฐ์ค์น ์๋ ๊ทธ๋ํ
โ
์์ ๊ฐ์ค์น
โ
์์ ๊ฐ์ค์น
โ (Bellman-Ford ์ฌ์ฉ)
๋ฌด๋ฐฉํฅ ๊ทธ๋ํ
โ
๋ฐฉํฅ ๊ทธ๋ํ
โ
์ต๋จ ๊ฒฝ๋ก ์ญ์ถ์
โ (์ด์ ๋ ธ๋ ๋ฐฐ์ด ํ์ฉ)
6. ์์ - ๊ฐ๋จํ ์
๋ ฅ ์
๋ฌธ์
์ ์ ์: 6๊ฐ
๊ฐ์ :
1 โ 2 (2)
1 โ 3 (5)
2 โ 3 (1)
2 โ 4 (2)
3 โ 4 (3)
์์ ๋ ธ๋ : 1
์ถ๋ ฅ(1์์ ๊ฐ ์ ์ ๊น์ง ์ต๋จ ๊ฑฐ๋ฆฌ)
1๋ฒ: 0
2๋ฒ: 2
3๋ฒ: 3
4๋ฒ: 4
7. Dijkstra ๋ก ์์ฃผ ๋์ค๋ ๋ฌธ์ ์ ํ
๊ธฐ๋ณธ ์ต๋จ ๊ฒฝ๋ก
ํ๋์ ์์์ โ ๋ชจ๋ ๋ ธ๋ ์ต๋จ ๊ฑฐ๋ฆฌ
๋์ฐฉ์ ์ ํ
์์ โ ๋์ฐฉ์ ํ๋๋ง
๊ฒฝ๋ก ์ญ์ถ์
์ต๋จ ๊ฑฐ๋ฆฌ๋ฟ ์๋๋ผ, "์ด๋ป๊ฒ" ์ด๋ํ๋์ง๋ ์ถ๋ ฅ
๊ฒฝ์ ์ง ํฌํจ
ํน์ ์ ์ ์ ๋ฐ๋์ ๋ค๋ฌ์ผ ํจ (๊ฒฝ๋ก A โ B โ C)
๊ฑฐ๋ฆฌ ์ ํ
์ต๋จ ๊ฒฝ๋ก๊ฐ ํน์ ๊ฑฐ๋ฆฌ ์ดํ์ธ ๊ฒฝ์ฐ๋ง ์ ํจ
2์ฐจ์ ๋งต ์ต๋จ ๊ฒฝ๋ก
BFS๋ณด๋ค ์ ๋ฐํ ๊ฑฐ๋ฆฌ ๊ณ์ฐ ํ์ํ ๋
8. ๊ด๋ จ ์๊ณ ๋ฆฌ์ฆ
BFS
๋ชจ๋ ๊ฐ์ ๊ฐ์ค์น๊ฐ ๋์ผํ ๋ Dijkstra ๋์ ์ฌ์ฉ ๊ฐ๋ฅ (O(V + E)
)
Bellman-Ford
์์ ๊ฐ์ค์น ํ์ฉ, ๋๋ฆผ
Floyd-Warshall
๋ชจ๋ ์ ์ ๊ฐ ์ต๋จ ๊ฑฐ๋ฆฌ (O(Nยณ)
), ์ ์ ์ ์ ์ ๋
A*
ํด๋ฆฌ์คํฑ์ ์ฌ์ฉํ ์ต์ ํ๋ ์ต๋จ ๊ฒฝ๋ก ํ์ (๊ฒ์, ๋ค๋น๊ฒ์ด์ ๋ฑ)
์์ฝ
[Start]
โ
์ฐ์ ์์ ํ์์ ๊ฐ์ฅ ์์ ๊ฑฐ๋ฆฌ ๋
ธ๋ ๊บผ๋
โ
์ธ์ ๋
ธ๋ ํ์ธ
โ
๊ฑฐ๋ฆฌ ๊ฐฑ์ ์, ๋ค์ ํ์ ๋ฃ์
โ
๋ชจ๋ ๋
ธ๋ ์ฒ๋ฆฌ๋ ๋๊น์ง ๋ฐ๋ณต
Last updated
Was this helpful?