📚 최단 경로 알고리즘
그래프상에서 가장 짧은 경로를 찾는 알고리즘
| 알고리즘 종류 | 시간 복잡도 | 구현 난이도 | 역할 |
|---|---|---|---|
| 다익스트라 | O(ElogV) | 어려운 편 | 한 지점에서 다른 모든 지점까지의 최단 경로를 계산한다. |
| 플로이드 워셜 | O(V^3) | 쉬운 편 | 모든 지점에서 다른 모든 지점까지의 최단 경로를 계산한다. |
📖 A. 다익스트라 알고리즘
'단계마다 방문하지 않은 노드 중에서 최단 거리가 짧은 노드를 선택' 한 뒤에, 그 노드를 거쳐 가는 경우를 확인하여 최단 거리를 갱신하는 방법
- 우선순위 큐를 이용하여 소스코드를 작성할 수 있다.
📖 B. 플로이드 워셜 알고리즘
다이나믹 프로그래밍을 이용하여 단계마다 '거쳐 가는 노드'를 기준으로, 최단 거리 테이블을 갱신하는 방식으로 동작한다.
- 점화식 :
Dab=min(Dab,Dak + Dkb)
for k in range(1, n + 1):
for a in range(1, n + 1):
for b in range(1, n + 1):
adj[a][b] = min(adj[a][b], adj[a][k] + adj[k][b])
최단 경로 문제로 보이지 않더라도, 최소 비용을 구해야 하는 다양한 문제에 최단 경로 알고리즘을 적용할 수 있는 경우가 많기 때문에 구현 방법을 기억해 놓는 것이 유리하다.
📚 문제
📖 Q 37 플로이드
전형적인 최단 경로 문제이다.
문제의 입력 조건에 따르면, 시작 도시 A와 도착 도시 B를 연결하는 간선이 여러 개일 수 있다는 점을 알 수 있다.
이럴 경우 비용이 짧은 간선만 고려하면 된다.
도시의 개수가 n이 100이하의 정수이므로, 플로이드 워셜 알고리즘을 이용하는 것이 효과적이다.
# 노드의 개수 및 간선의 개수를 입력받기
n = int(input())
m = int(input())
INF = int(1e9) # 무한을 의미하는 값으로 10억을 설정
# 2차원 리스트(그래프 표현)을 만들고, 모든 값을 무한으로 초기화
graph = [[INF] * (n + 1) for _ in range(n + 1)]
# 자기 자신에게 자기 자신으로 가는 비용은 0으로 초기화
for i in range(1, n + 1):
for j in range(1, n + 1):
if i == j:
graph[i][j] = 0
# 각 간선에 대한 정보를 입력받아, 그 값으로 초기화
for _ in range(m):
# A에서 B로 가는 비용은 C라고 설정
a, b, c = map(int, input().split())
# 가장 짧은 간선 정보만 저장
if graph[a][b] > c:
graph[a][b] = c
# 점화식에 따라 플로이드 워셜 알고리즘을 수행
for k in range(1, n + 1):
for i in range(1, n + 1):
for j in range(1, n + 1):
graph[i][j] = min(graph[i][j], graph[i][k] + graph[k][j])
# 수행된 결과를 출력
for i in range(1, n + 1):
for j in range(1, n + 1):
# 도달할 수 없는 경우, 0을 출력
if graph[i][j] >= INF:
print(0, end=" ")
# 도달할 수 있는 경우 거리를 출력
else:
print(graph[i][j], end=" ")
print()
📖 Q 38 정확한 순위
최단 경로를 계산하는 문제로 볼 수 있다.
학생들의 성적을 비교한 결과를 방향 그래프 형태로 표현할 수 있다.
성적이 낮은 학생이 성적이 높은 학생을 가리키는 방향 그래프로 표현할 수 있으므로, 최단 경로 알고리즘을 수행할 수 있게 된다.
A번 학생과 B번 학생의 성적을 비교할 때, '경로'를 이용하여 성적 비교 결과를 알 수 있다.
A에서 B로 도달이 가능하거나, B에서 A로 도달이 가능하면 '성적 비교'가 가능한 것이다.
반대로 A에서 B로 도달이 불가능하며, B에서 A로도 도달이 불가능하다면, '성적 비교 결과를 알 수 없는' 경우가 되는 것이다.
학생의 수 N이 500이하의 정수이므로 O(N^3)의 시간 복잡도로 동작하는 플로이드 워셜 알고리즘을 이용해 문제를 해결할 수 있다.
따라서 플로이드 워셜 알고리즘을 수행한 뒤에, 모든 노드에 대하여 다른 노드와 서로 도달이 가능한지를 체크하여 문제를 해결할 수 있다.
이때 자기 자신은 항상 도달이 가능하다고 보고, 카운트를 진행한다.
결과적으로 특정한 노드의 카운트 값이 N이라면, 해당 노드의 정확한 순위를 알 수 있다는 것을 의미한다.
INF = int(1e9) # 무한을 의미하는 값으로 10억을 설정
# 노드의 개수, 간선의 개수를 입력받기
n, m = map(int, input().split())
# 2차원 리스트(그래프 표현)을 만들고, 모든 값을 무한으로 초기화
graph = [[INF] * (n + 1) for _ in range(n + 1)]
# 자기 자신에게 자기 자신으로 가는 비용은 0으로 초기화
for a in range(1, n+1):
for b in range(1, n+1):
if a == b:
graph[a][b] = 0
# 각 간선에 대한 정보를 입력받아, 그 값으로 초기화
for _ in range(m):
# A에서 B로 가는 비용을 1로 설정
a, b = map(int, input().split())
graph[a][b] = 1
# 점화식에 따라 플로이드 워셜 알고리즘을 수행
for k in range(1, n + 1):
for a in range(1, n + 1):
for b in range(1, n + 1):
graph[a][b] = min(graph[a][b],graph[a][k] + graph[k][b])
result = 0
# 각 학생을 번호에 따라 한 명씩 확인하며 도달 가능한지 체크
for i in range(1, n + 1):
count = 0
for j in range(1, n + 1):
if graph[i][j] != INF or graph[j][i] != INF:
count += 1
if count == n:
result += 1
print(result)
📖 Q 39 화성 탐사
(0, 0)의 위치에서 (N - 1, N - 1)의 위치로 이동하는 최단 거리를 계산하는 문제로 이해할 수 있다.
NxN 크기의 맵이 주어졌을 때, 맵의 각 위치(칸)를 '노드'로 보고, 상하좌우로 모든 노드가 연결되어 있다고 보면 된다.
입력 자체가 2차원 배열로 들어오기 때문에, NxN 인접 행렬을 이용해 맵 정보를 저장하면 그래프를 간단히 표현할 수 있다.
N 범위 크기가 최대 125이므로 2차원 공간이기 때문에 전체 노드의 개수는 N^2으로 10,000을 넘을 수 있다.
플로이드 워셜 알고리즘으로 이 문제를 해결하기보다는 다익스트라 최단 경로 알고리즘을 이용하면 효과적으로 답을 도출할 수 있다.
import heapq
import sys
input = sys.stdin.readline
INF = int(1e9)
dx = [-1, 0, 1, 0]
dy = [0, 1, 0, -1]
# 전체 테스트 케이스(Test Case) 만큼 반복
for tc in range(int(input())):
# 노드의 개수를 입력받기
n = int(input())
# 전체 맵 정보를 입력받기
graph = []
for i in range(n):
graph.append(list(map(int, input().split())))
# 최단 거리 테이블을 모두 무한으로 초기화
distance = [[INF] * n for _ in range(n)]
x, y = 0, 0 # 시작 위치는 (0, 0)
# 시작 노드로 가기 위한 비용은 (0, 0) 위치의 값으로 설정하여, 큐에 삽입
q = [(graph[x][y], x, y)]
distance[x][y] = graph[x][y]
# 다익스트라 알고리즘 수행
while q:
# 가장 최단 거리가 짧은 노드에 대한 정보를 꺼내기
dist, x, y = heapq.heappop(q)
# 현재 노드가 이미 처리된 적이 있는 노드라면 무시
if distance[x][y] < dist:
continue
# 현재 노드와 연결된 다른 인접한 노드들을 확인
for i in range(4):
nx = x + dx[i]
ny = y + dy[i]
# 맵의 범위를 벗어나는 경우 무시
if nx < 0 or nx >= n or ny < 0 or ny >= n:
continue
cost = dist + graph[nx][ny]
# 현재 노드를 거쳐서, 다른 노드로 이동하는 거리가 더 짧은 경우
if cost < distance[nx][ny]:
distance[nx][ny] = cost
heapq.heappush(q, (cost, nx, ny))
print(distance[n - 1][n - 1])
📖 Q 40 숨바꼭질
다익스트라 알고리즘을 이용하여 1번 노드 (헛간)로부터 다른 모든 노드로의 최단 거리를 계산한 뒤에, 가장 최단 거리가 긴 노드를 찾는 문제이다.
예제)
6 7
3 6
4 3
1 3
1 2
2 4
5 2
항상 출발 노드는 1번 노드라고 문제에서 명시하였으므로, 다익스트라 알고리즘을 이용하여 1번 노드에서 출발했을 때의 모든 최단 거리를 계산하면 다음과 같은 최단 거리 테이블을 구할 수 있다.
| 노드1 | 노드2 | 노드3 | 노드4 | 노드5 | 노드6 |
|---|---|---|---|---|---|
| 0 | 1 | 1 | 2 | 2 | 2 |
이 예시에서 최단 거리가 가장 긴 노드까지의 최단 거리는 '2'라는 것을 알 수 있다.
최단 거리가 2인 노드가 3개인 것을 확인할 수 있다.
문제에서는 최단 거리가 같은 헛간이 여러 개이면 가장 작은 헛간 번호를 출력하라고 하였으므로, 이 경우 4번 노드를 출력하면 된다.
즉, 최단 거리 테이블을 구한 이후에는 손쉽게 문제에서 요구하는 답을 도출할 수 있다.
또한, 문제에서의 거리가 1이기 때문에 BFS를 이용하여 최단 거리를 계산할 수도 있지만, 여기에서는 다익스트라 알고리즘을 이용하여 문제를 해결해보자.
import heapq
import sys
input = sys.stdin.readline
INF = int(1e9) # 무한을 의미하는 값으로 10억을 설정
# 노드의 개수, 간선의 개수를 입력받기
n, m = map(int, input().split())
# 시작 노드를 1번 헛간으로 설정
start = 1
# 각 노드에 연결되어 있는 노드에 대한 정보를 담는 리스트를 만들기
graph = [[] for i in range(n + 1)]
# 최단 거리 테이블을 모두 무한으로 초기화
distance = [INF] * (n+1)
# 모든 간선 정보를 입력받기
for _ in range(m):
a, b = map(int, input().split())
# a번 노드와 b번 노드의 이동 비용이 1이라는 의미(양방향)
graph[a].append((b, 1))
graph[b].append((a, 1))
def dijkstra(start):
q = []
# 시작 노드로 가기 위한 최단 경로는 0으로 설정하여, 큐에 삽입
heapq.heappush(q, (0, start))
distance[start] = 0
while q: # 큐가 비어있지 않다면
# 가장 최단 거리가 짧은 노드에 대한 정보를 꺼내기
dist, now = heapq.heappop(q)
# 현재 노드가 이미 처리된 적이 있는 노드라면 무시
if distance[now] < dist:
continue
# 현재 노드와 연결된 다른 인접한 노드들을 확인
for i in graph[now]:
cost = dist + i[1]
# 현재 노드를 거쳐서, 다른 노드로 이동하는 거리가 더 짧은 경우
if cost < distance[i[0]]:
distance[i[0]] = cost
heapq.heappush(q, (cost, i[0]))
# 다익스트라 알고리즘 수행
dijkstra(start)
# 최단 거리가 가장 먼 노드 번호(동빈이가 숨을 헛간의 번호)
max_node = 0
# 도달할 수 있는 노드 중에서, 최단 거리가 가장 먼 노드와의 최단 거리
max_distance = 0
# 최단 거리가 가장 먼 노드와의 최단 거리와 동일한 최단 거리를 가지는 노드들의 리스트
result = []
for i in range(1, n + 1):
if max_distance < distance[i]:
max_node = i
max_distance = distance[i]
result = [max_node] # list 선언, max_node 삽입
elif max_distance == distance[i]:
result.append(i)
print(result)
print(max_node, max_distance, len(result))
