최단 경로 알고리즘 - 다익스트라 알고리즘 기본 버전
- Algorithm/Concept
- 2021. 12. 3.
최단 경로 알고리즘 (Shortest Path)
가장 짧은 경로를 찾는 알고리즘이다.
1) 한 지점에서 다른 특정 지점까지의 최단 경로를 구하는 경우
2) 모든 지점에서 다른 모든 지점까지의 최단 경로를 모두 구해야 하는 경우
최단 경로 알고리즘을 사용해야 하는 사례는 위 2가지 외에도 다양하다. 최단 경로 문제는 보통 '그래프'를 이용하여 풀이한다. 각 지점은 그래프에서 '노드'로 표현되고, 지점간 연결된 도로는 그래프에서 '간선'으로 표현된다.
최단 경로 알고리즘에서 꼭 알아야하는 유형은 아래 두가지다.
1) 다익스트라 최단 경로
2) 플로이드 워셜 알고리즘
플로이드 워셜 알고리즘은 다음 포스팅을 참고하자.
https://devfunny.tistory.com/648
최단경로 찾기 - 플로이드 워셜 알고리즘
플로이드 워셜 알고리즘 (Floyed-Warshall Algorithm) 프로이드 워셜 알고리즘은 '모든 지점에서 다른 모든 지점까지의 최단 경로를 모두 구해야 하는 경우' 사용하는 알고리즘이다. 단계마다 '거쳐가는
devfunny.tistory.com
다익스트라 최단 경로 (Dijkstra)
그래프에서 여러 개의 노드가 있을때, 특정한 노드에서 출발하여 다른 노드로 가는 각각의 최단 경로를 구해주는 알고리즘이다. '음의 간건'이 없을 때 정상적으로 동작한다.
음의 간선
0보다 작은 값을 가지는 간선으로, 현실에서는 음의 간선은 표현되지 않는다.
다익스트라 최단 경로 알고리즘은 기본적으로 '그리디 알고리즘'으로 분류된다. 매번 '가장 비용이 적은 노드'를 선택해서 임의의 과정을 반복하기 때문이다.
다익스트라 최단 경로 알고리즘의 원리에 대해 알아보자.
1) 출발 노드를 선정한다.
2) 최단 거리 테이블을 초기화한다.
3) 방문하지 않은 노드 중에서 최단 거리가 가장 짧은 노드를 선택한다.
4) 해당 노드를 거쳐 다른 노드로 가는 비용을 계산하여 최단 거리 테이블을 갱싱한다.
5) 위 과정에서 3번, 4번을 반복한다.
최단 경로를 구하는 과정에서 '각 노드에 대한 현재까지의 최단거리' 정보를 1차원 리스트에 저장하여 리스트를 항상 갱신한다는 특징이 있다. 매번 현재 처리하고 있는 노드를 기준으로 주변 간선을 확인한다. 나중에 현재 처리하고 있는 노드와 인접한 노드로 도달하는 더 짧은 경로를 찾으면 해당 짧은 경로로 업데이트한다. 즉, '방문하지 않은 노드 중에서 현재 최단 거리가 가장 짧은 노드를 확인하는 그리디 알고리즘' 이라고 할 수 있다.
그리디 알고리즘 동작 원리
| 노드 번호 | 1 | 2 | 3 | 4 | 5 | 6 |
| 거리 | 0 | 무한 | 무한 | 무한 | 무한 | 무한 |
[1] 노드 방문
| 노드 번호 | 1 | 2 | 3 | 4 | 5 | 6 |
| 거리 | 0 | 2 | 5 | 1 | 무한 | 무한 |
[4] 노드 방문
[1] 노드와 최단 거리가 가장 짧은 노드인 4번 노드를 선택한다.
1) 여기서, [3] 노드에 주목하자. [1] 노드 -> [3] 노드 보다, [1] -> [4] -> [3] 노드로 가는 것이 거리가 더 짧다. 그러므로 갱신된다.
2) [5] 노드도 [1] -> [4] -> [5] 가 2이므로 2로 갱신된다.
| 노드 번호 | 1 | 2 | 3 | 4 | 5 | 6 |
| 거리 | 0 | 2 | 4 | 1 | 2 | 무한 |
[2] 노드 방문
그 다음은 [2] 노드가 선택된다.
1) [1] -> [2] -> [3] : 5
더 짧은 경로가 없으므로 갱신되지 않는다.
| 노드 번호 | 1 | 2 | 3 | 4 | 5 | 6 |
| 거리 | 0 | 2 | 4 | 1 | 2 | 무한 |
[5] 노드 방문
1) [1] -> [4] -> [5] -> [3] : 3
2) [1] -> [4] -> [5] -> [6] : 4
| 노드 번호 | 1 | 2 | 3 | 4 | 5 | 6 |
| 거리 | 0 | 2 | 3 | 1 | 2 | 4 |
[3] 노드 방문
| 노드 번호 | 1 | 2 | 3 | 4 | 5 | 6 |
| 거리 | 0 | 2 | 3 | 1 | 2 | 4 |
마지막 [6] 노드 방문
| 노드 번호 | 1 | 2 | 3 | 4 | 5 | 6 |
| 거리 | 0 | 2 | 3 | 1 | 2 | 4 |
결국, 최종 결과는 아래와 같다.
| 노드 번호 | 1 | 2 | 3 | 4 | 5 | 6 |
| 거리 | 0 | 2 | 3 | 1 | 2 | 4 |
이는 1번 노드로부터 출발했을 때 2번, 3번, 4번, 5번, 6번 노드까지 가기위한 최단 경로가 각각 2, 3, 1, 2, 4 라는 의미다. 방문하지 않은 노드 중에서 가장 최단 거리가 짧은 노드를 선택하는 과정을 반복하는데, 이렇게 선택된 노드는 '최단 거리'가 완전히 선택된 노드이므로, 더이상 알고리즘을 반복해도 최단 거리가 줄어들지 않는다. 다시말해 다익스트라 알고리즘이 진행되면서 한단계당 하나의 노드에 대한 최단 거리를 확실히 찾는 것으로 이해할 수 있다. 결국, 마지막 노드에 대해서는 해당 노드를 거쳐 다른 노드로 가는 경우를 확인할 필요가 없다.
다익스트라 알고리즘 소스코드
위 동작 원리를 직관적으로 구현해보자. 알고리즘을 그대로 구현해보고, 간단한 다익스트라 알고리즘은 O(V2)의 시간 복잡도를 가진다.
코드를 단계적으로 작성해보자.
1단계. Node 클래스 선언
class Node {
private int index; /* 노드 번호 */
private int distance; /* 최단 경로 */
public Node(int index, int distance) {
this.index = index;
this.distance = distance;
}
public int getIndex() {
return this.index;
}
public int getDistance() {
return this.distance;
}
}
2단계. 그래프 입력받기
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class Dijkstra {
/* 무한을 의미하는 값으로 10억을 설정 */
public static final int INF = (int) 1e9;
public static int n; // 노드의 개수(N)
public static int m; // 간선의 개수(M)
public static int start; // 시작 노드 번호(Start)
/* 각 노드에 연결되어 있는 노드에 대한 정보를 담는 배열 */
public static ArrayList<ArrayList<Node>> graph = new ArrayList<ArrayList<Node>>();
/* 방문한 적이 있는지 체크하는 목적의 배열 만들기 */
public static boolean[] visited = new boolean[100001];
/* 최단 거리 테이블 만들기 */
public static int[] d = new int[100001];
public static void main(String[] args) {
input();
}
private static void input() {
Scanner sc = new Scanner(System.in);
n = sc.nextInt(); // 노드의 개수(N)
m = sc.nextInt(); // 간선의 개수(M)
start = sc.nextInt(); // 시작 노드 번호(Start)
/* 그래프 초기화 */
for (int i = 0; i <= n; i++) {
graph.add(new ArrayList<Node>());
}
/* 모든 간선 정보를 입력받기 */
for (int i = 0; i < m; i++) {
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
/* a번 노드에서 b번 노드로 가는 비용이 c라는 의미 */
graph.get(a).add(new Node(b, c));
}
/* 최단 거리 테이블을 모두 무한으로 초기화 */
Arrays.fill(d, INF);
}
}
입력 과정을 보자. 아래 입력은 위에서 우리가 봐온 동작 원리의 그림과 동일하다.
1) console
2) graph
[1번 노드]
- 1번 노드 -> 2번 노드까지의 비용 : 2
- 1번 노드 -> 3번 노드까지의 비용 : 5
- 1번 노드 -> 4번 노드까지의 비용 : 1
[2번 노드]
- 2번 노드 -> 3번 노드까지의 비용 : 3
- 2번 노드 -> 4번 노드까지의 비용 : 2
.
.
graph.get(a).add(new Node(b, c));
결국, a 번 노드에서 b번 노드까지의 비용이 c이라는 의미다.
3단계. getSmallestNode() 메서드 생성
...
/**
* 방문하지 않은 노드 중에서, 가장 최단 거리가 짧은 노드의 번호를 반환
* @return
*/
private static int getSmallestNode() {
int min_value = INF;
int index = 0; // 가장 최단 거리가 짧은 노드(인덱스)
/* 최단거리 노드번호 구하기 */
for (int i = 1; i <= n; i++) {
if (d[i] < min_value && !visited[i]) {
min_value = d[i];
index = i;
}
}
return index;
}
...
해당 메서드를 호출하는 시점까지 저장한 각 노드까지의 최단경로가 저장되어있는 배열 d 의 최소값을 찾으면 된다.
4단계. dijkstra(int start) 메서드 생성
private static void dijkstra(int start) {
/* 시작 노드에 대해서 초기화 */
d[start] = 0;
/* 방문 처리 */
visited[start] = true;
/* start 노드와 연결되어있는 노드의 개수만큼 반복 */
for (int j = 0; j < graph.get(start).size(); j++) {
/* '연결된 노드 번호' 번째의 d 배열에 '연결된 노드 번호' 번째의 비용 저장 */
d[graph.get(start).get(j).getIndex()] = graph.get(start).get(j).getDistance();
}
/* 시작 노드를 제외한 전체 n - 1개의 노드에 대해 반복 */
for (int i = 0; i < n - 1; i++) {
/* 현재 최단 거리가 가장 짧은 노드를 꺼내서, 방문 처리 */
int now = getSmallestNode();
/* 방문 처리 */
visited[now] = true;
/* (짧은 노드를 우선적 방문) 현재 노드와 연결된 다른 노드를 확인 */
for (int j = 0; j < graph.get(now).size(); j++) {
/* 현재의 최단거리 + 현재의 연결된 노드의 비용 */
int cost = d[now] + graph.get(now).get(j).getDistance();
/* 현재 노드를 거쳐서 다른 노드로 이동하는 거리가 더 짧은 경우 */
if (cost < d[graph.get(now).get(j).getIndex()]) {
d[graph.get(now).get(j).getIndex()] = cost;
}
}
}
}
주석을 따라가며 코드를 이해하자.
1) graph.get(start).get(j) : start 노드와 연결된 노드다. getIndex()를 통해 연결된 노드 번호를 얻는다.
2) graph.get(start).get(j).getDistance() : 노드 번호 index에 해당하는 d 배열에 비용을 저장한다.
/* start 노드와 연결되어있는 노드의 개수만큼 반복 */
for (int j = 0; j < graph.get(start).size(); j++) {
/* '연결된 노드 번호' 번째의 d 배열에 '연결된 노드 번호' 번째의 비용 저장 */
d[graph.get(start).get(j).getIndex()] = graph.get(start).get(j).getDistance();
}
3) 반복문 실행
/* 시작 노드를 제외한 전체 n - 1개의 노드에 대해 반복 */
for (int i = 0; i < n - 1; i++) {
...
}
여기서 i는 단지 반복문 횟수를 위한 변수다. 시작 노드를 제외하므로 n - 1 보다 작을때까지 반복한다.
/* (짧은 노드를 우선적 방문) 현재 노드와 연결된 다른 노드를 확인 */
for (int j = 0; j < graph.get(now).size(); j++) {
...
}
now는 getSmallestNode() 함수로 얻어온 노드의 번호다. 해당 함수는 위에 2단계에서도 말했듯, d 배열에서 최단 거리가 가장 짧은 노드 번호를 얻는다. 따라서 graph.get(now) 는 다음 방문 대상인 노드다.
해당 반복문으로 방문 대상 노드의 연결된 노드 개수만큼 반복한다.
/* 현재의 최단거리 + 현재의 연결된 노드의 비용 */
int cost = d[now] + graph.get(now).get(j).getDistance();
d[now] 는 현재 방문한 now 노드의 저장되어있는 최단 경로다. now번 노드의 현재 최단 경로와 현재 연결된 노드의 비용을 합친 것이 새로 구한 비용이다.
/* 현재 노드를 거쳐서 다른 노드로 이동하는 거리가 더 짧은 경우 */
if (cost < d[graph.get(now).get(j).getIndex()]) {
d[graph.get(now).get(j).getIndex()] = cost;
}
위에서 구한 비용과 배열 d의 현재 대상인 연결 노드의 번호번째의 최단 경로를 비교한다. 더 작다면, 갱신한다.
5단계. 결과 출력
...
public static void main(String[] args) {
input();
/* 다익스트라 알고리즘을 수행 */
dijkstra(start);
/* 도달할 수 있는 경우 거리 출력 (1부터 시작했으므로 n + 1) */
IntStream.range(0, n + 1).filter(i -> d[i] != INF).mapToObj(i -> d[i]).forEach(System.out::println);
}
...
d 배열에서 INF가 아닌 데이터를 필터링하여 출력한다.
최종 코드
package Y19_ShortestPath;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.util.stream.IntStream;
public class Dijkstra {
/* 무한을 의미하는 값으로 10억을 설정 */
public static final int INF = (int) 1e9;
public static int n; // 노드의 개수(N)
public static int m; // 간선의 개수(M)
public static int start; // 시작 노드 번호(Start)
/* 각 노드에 연결되어 있는 노드에 대한 정보를 담는 배열 */
public static ArrayList<ArrayList<Node>> graph = new ArrayList<ArrayList<Node>>();
/* 방문한 적이 있는지 체크하는 목적의 배열 만들기 */
public static boolean[] visited = new boolean[100001];
/* 최단 거리 테이블 만들기 */
public static int[] d = new int[100001];
public static void main(String[] args) {
input();
/* 다익스트라 알고리즘을 수행 */
dijkstra(start);
/* 도달할 수 있는 경우 거리 출력 (1부터 시작했으므로 n + 1) */
IntStream.range(0, n + 1).filter(i -> d[i] != INF).mapToObj(i -> d[i]).forEach(System.out::println);
}
private static void dijkstra(int start) {
/* 시작 노드에 대해서 초기화 */
d[start] = 0;
/* 방문 처리 */
visited[start] = true;
/* start 노드와 연결되어있는 노드의 개수만큼 반복 */
for (int j = 0; j < graph.get(start).size(); j++) {
/* '연결된 노드 번호' 번째의 d 배열에 '연결된 노드 번호' 번째의 비용 저장 */
d[graph.get(start).get(j).getIndex()] = graph.get(start).get(j).getDistance();
}
/* 시작 노드를 제외한 전체 n - 1개의 노드에 대해 반복 */
for (int i = 0; i < n - 1; i++) {
/* 현재 최단 거리가 가장 짧은 노드를 꺼내서, 방문 처리 */
int now = getSmallestNode();
/* 방문 처리 */
visited[now] = true;
/* (짧은 노드를 우선적 방문) 현재 노드와 연결된 다른 노드를 확인 */
for (int j = 0; j < graph.get(now).size(); j++) {
/* 현재의 최단거리 + 현재의 연결된 노드의 비용 */
int cost = d[now] + graph.get(now).get(j).getDistance();
/* 현재 노드를 거쳐서 다른 노드로 이동하는 거리가 더 짧은 경우 */
if (cost < d[graph.get(now).get(j).getIndex()]) {
d[graph.get(now).get(j).getIndex()] = cost;
}
}
}
}
/**
* 방문하지 않은 노드 중에서, 가장 최단 거리가 짧은 노드의 번호를 반환
* @return
*/
private static int getSmallestNode() {
int min_value = INF;
int index = 0; // 가장 최단 거리가 짧은 노드(인덱스)
/* 최단거리 노드번호 구하기 */
for (int i = 1; i <= n; i++) {
if (d[i] < min_value && !visited[i]) {
min_value = d[i];
index = i;
}
}
return index;
}
private static void input() {
Scanner sc = new Scanner(System.in);
n = sc.nextInt(); // 노드의 개수(N)
m = sc.nextInt(); // 간선의 개수(M)
start = sc.nextInt(); // 시작 노드 번호(Start)
/* 그래프 초기화 */
for (int i = 0; i <= n; i++) {
graph.add(new ArrayList<Node>());
}
/* 모든 간선 정보를 입력받기 */
for (int i = 0; i < m; i++) {
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
/* a번 노드에서 b번 노드로 가는 비용이 c라는 의미 */
graph.get(a).add(new Node(b, c));
}
/* 최단 거리 테이블을 모두 무한으로 초기화 */
Arrays.fill(d, INF);
}
}
class Node {
private int index; /* 노드 번호 */
private int distance; /* 최단 경로 */
public Node(int index, int distance) {
this.index = index;
this.distance = distance;
}
public int getIndex() {
return this.index;
}
public int getDistance() {
return this.distance;
}
}
입력
6 11
1
1 2 2
1 3 5
1 4 1
2 3 3
2 4 2
3 2 3
3 6 5
4 3 3
4 5 1
5 3 1
5 6 2
출력
0
2
3
1
2
4
시간복잡도
해당 알고리즘의 시간 복잡도는 O(V 제곱) 이다. O(V)번에 걸쳐서 최단 거리가 가장 짧은 노드를 매번 선형 탐색하고, 현재 노드와 연결된 노드를 일일이 확인하기 때문이다.
최단 경로 문제에서 전체 노드의 개수가 5,000개 이하라면 일반적으로 이 코드로 문제를 풀 수 있다. 하지만 10,000개를 넘어가는 문제라면 다른 '개선된 다익스트라 알고리즘'을 이용해야한다. 이건 다음 포스팅에서 공부하자.
개선된 다익스트라 알고리즘 포스팅 바로가기
https://devfunny.tistory.com/641
최단 경로 알고리즘 - 다익스트라 알고리즘 우선순위 큐 사용 버전
들어가기전 기본 다익스트라 알고리즘에 대해 먼저 공부하자. https://devfunny.tistory.com/638 최단 경로 알고리즘 - 다익스트라 알고리즘 기본 버전 최단 경로 알고리즘 (Shortest Path) 가장 짧은 경로를
devfunny.tistory.com
참고 도서 : 이것이 코딩테스트다
'Algorithm > Concept' 카테고리의 다른 글
| 최소 신장트리 알고리즘, 크루스칼 알고리즘 (Kruskal) (0) | 2021.12.15 |
|---|---|
| 서로소 집합 (Disjoint Sets) 알고리즘 (0) | 2021.12.15 |
| 최단경로 찾기 - 플로이드 워셜 알고리즘 (0) | 2021.12.08 |
| 우선순위 큐 (Priority Queue) (0) | 2021.12.03 |
| 최단 경로 알고리즘 - 다익스트라 알고리즘 우선순위 큐 사용 버전 (2) | 2021.12.03 |