๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ์ด ๋ญ๊น?
๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ์ด๋
ํ๋์ ์ถ๋ฐ์ ์์ ๋๋ฌํ ์ ์๋ ๋ชจ๋ ๋์ฐฉ์ ์ ๋ํ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ๊ตฌํ ์ ์๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ค.
๋์ ์กฐ๊ฑด์ด ์๋๋ฐ ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ์ ๊ฐ์ ๋ค์ ๋น์ฉ์ด ๋ชจ๋ ์์์ฌ์ผ๋ง ์ ์ฉ์ด ๊ฐ๋ฅํ๋ค. ๋ง์ฝ ์์ ๋น์ฉ์ ๊ฐ์ง ๊ฐ์ ์ด ์กด์ฌํ๋ค๋ฉด ์ต๋จ ๊ฒฝ๋ก๋ฅผ ๊ตฌํ ์ ์๋ค.
๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ๊ณผ ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ
๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ์ ๋ฉ์ธ ์์ด๋์ด๋ ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ(DP)์ด๋ค. ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ์ ๊ธฐ์กด์ ๊ตฌํด๋์ ์ต๋จ ๊ฑฐ๋ฆฌ๋ฅผ ์ด์ฉํ์ฌ ์ต๋จ ๊ฑฐ๋ฆฌ๋ฅผ ๊ฐฑ์ ํด๋๊ฐ๋ ๋ฉ์ธ ์์ด๋์ด๋ฅผ ๊ฐ์ง๊ณ ์๋ค. (์ต๋จ ๊ฒฝ๋ก๋ ์ต๋จ ๊ฒฝ๋ก๋ค์ ์งํฉ์ผ๋ก ์ด๋ฃจ์ด์ ธ ์๋ค)
๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ์ ๋ณต์ก๋ (์ข ๋ ์์ธํ ์์๋ณผ ๊ฒ)
์๋ ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ์ O(V^2)์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ง๊ณ ์์์ง๋ง ์ฐ์ ์์ ํ๋ฅผ ํ์ฉํ ๋ฐ์ ๋ ์์ด๋์ด๊ฐ ์ ๊ณต๋๋ฉด์ O(E * lgV)์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ง ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ๊ฐ์ ๋์๋ค. (V๋ ๋ ธ๋์ ์, E๋ ๊ฐ์ ์ ์)
๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ ๋ก์ง
1. ์์ ๋ ธ๋๋ฅผ ์ ํํ์ฌ, ์ฐ์ ์์ํ์ ์ฝ์ ํ๋ค.
1-1. ์์ ๋ ธ๋์ ์ต๋จ ๊ฒฝ๋ก๋ฅผ 0์ผ๋ก ์ด๊ธฐํ ํ๊ณ , ๋๋จธ์ง ๋ ธ๋๋ ๋ฌดํ๋ ๊ฐ์ผ๋ก ์ด๊ธฐํํ๋ค.
2. ์ฐ์ ์์ ํ(Min Heap)์์ ๊ฐ์ฅ ์์ ๋น์ฉ์ ๊ฐ์ง ๋ ธ๋๋ฅผ ๊บผ๋ธ๋ค.
2-1. ๊บผ๋ธ ๋ ธ๋์ ์ฐ๊ฒฐ๋ ๋ ธ๋๋ค์ ๊ฐ์ ธ์ ๋ฐ๋ณตํ๋ค.
2-1-1. u๊ฐ ์ถ๋ฐ ๋ ธ๋ v๊ฐ ๋ชฉ์ ์ง๋ผ๊ณ ํ ๋, ์ต๋จ ๊ฒฝ๋ก ๋น์ฉ[v] = Math.min(์ต๋จ ๊ฒฝ๋ก ๋น์ฉ[v], ์ต๋จ ๊ฒฝ๋ก ๋น์ฉ[u] + ๊ฒฝ๋ก ๋น์ฉ[u][v]) (s -> v, s -> u -> v) ์ ๋น๊ตํ๋ ๊ฒ
3. 2๋ฒ์ ์ฐ์ ์์ ํ์ ๋ ธ๋๊ฐ ์กด์ฌํ์ง ์์ ๋ ๊น์ง ๋ฐ๋ณตํ๋ค.
๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ ๊ตฌํ
private void dijkstra(int start) {
boolean[] check = new boolean[adjArray.length+1];
PriorityQueue<int[]> queue = new PriorityQueue<>(Comparator.comparingInt(o -> o[1]));
Arrays.fill(distance, Integer.MAX_VALUE);
distance[start] = 0;
queue.add(new int[]{start, 0});
while(!queue.isEmpty()) {
int[] u = queue.poll();
if(distance[u[0]] < u[1]) continue;;
LinkedList<Integer> connectedNodes = findConnectedNode(u[0]);
for(int v : connectedNodes) {
if(distance[v] > distance[u[0]] + adjArray[u[0]][v]) {
distance[v] = distance[u[0]] + adjArray[u[0]][v];
queue.add(new int[]{v, distance[v]});
}
}
}
}
private LinkedList<Integer> findConnectedNode(int u) {
LinkedList<Integer> connectedNodes = new LinkedList<>();
int[] adjLine = adjArray[u];
for(int i=1; i<adjLine.length; i++) {
if(adjLine[i] != 0) connectedNodes.add(i);
}
return connectedNodes;
}
Q1. if(distance[u[0]] < u[1])) continue; ๋ ์ ํ๋๊ฑธ๊น์?
๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ์ ๋ฉ์ธ ์์ด๋์ด๋ ๊ธฐ์กด์ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ํ์ฉํ์ฌ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ๊ตฌํ๋ ๋ก์ง์ธ๋ฐ, ์ต๋จ ๊ฒฝ๋ก๊ฐ ์๋๋ผ๋ฉด ๊ตณ์ด ๊ทธ๊ฒ์ ์ด์ฉํ์ฌ ๊ฐฑ์ ์ ์๋ํ ํ์๊ฐ ์๊ธฐ ๋๋ฌธ์ ํ๋๊ฒ๋๋ค.
Q2. if(distance[v] > distance[u[0]] + adjArray[u[0]][v]) ์ฌ์ผ queue์ ๋ ธ๋๋ฅผ ๋ฃ๋๊ฑด๊ฐ์?
์์ ์ง๋ฌธ์ ๋๋ต์ฒ๋ผ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ์ด์ฉํ์ฌ ์๋ก์ด ์ต๋จ ๊ฒฝ๋ก๋ฅผ ๊ตฌํ๋ ๋ก์ง์ธ๋ฐ, ๊ฐฑ์ ์ด ๋์ง ์์ (์ต์๊ฐ ์๋) ๊ฒฝ๋ก๋ฅผ ํ์ฉํ ํ์๋ ์๊ธฐ ๋๋ฌธ์ ๋๋ค.