shortest path : floyd-warshall, dijkstra, bellman-ford

Author: subinium

README.md

@@ -13,6 +13,15 @@
 
 ## Graph
 
+### Shotest Path
+
+- [Floyd-Warshall](/graph/shortest_path/floyd_warshall.py)
+  - [BOJ 11404 : 플로이드](https://www.acmicpc.net/problem/11404)
+- [Dijkstra](graph/shortest_path/dijkstra.py)
+  - [BOJ 1753 : 최단경로](https://www.acmicpc.net/problem/1753)
+- [Bellman-Ford](/graph/shortest_path/bellman_ford.py)
+  - [BOJ 11657 : 타임머신](https://www.acmicpc.net/problem/11657)
+
 ## String
 
 - [KMP](/string/kmp.py)

graph/shortest_path/bellman_ford.py

@@ -0,0 +1,25 @@
+# [BOJ 11657] 타임머신
+# link : https://www.acmicpc.net/problem/11657
+# tag : graph, bellman-ford, shortest path, negative cycle
+# @subinium
+
+# Bellman-Ford Algorthm
+def bellman_ford(v, edge, start=1):
+    INF = 1e10
+    dist = [INF for _ in range(v+1)]
+    dist[start] = 0
+    for i in range(1, v+1):
+        for st, ed, val in edge: # start, end, value
+            if dist[st] == INF: continue
+            if dist[ed] > dist[st] + val: 
+                dist[ed] = dist[st] + val
+                if i == v : return None, True
+    return dist, False
+
+# Main
+if __name__ == '__main__':
+    N, M = map(int, input().split())
+    edge = [tuple(map(int, input().split())) for _ in range(M)] # (from, to, time) 
+    dist, neg = bellman_ford(N, edge)
+    if neg : print(-1) # Negative Cycle
+    else : print('\n'.join(map(str, [i if i!=1e10 else -1 for i in dist[2:]])))

graph/shortest_path/dijkstra.py

@@ -0,0 +1,34 @@
+# [BOJ 1753] 최단경로
+# link : https://www.acmicpc.net/problem/1753
+# tag : graph, dijkstra, shortest path
+# @subinium
+
+import sys
+from heapq import heappop, heappush
+
+# Dijkstra Algorithm 
+def dijkstra(v, start, edge_raw):
+    INF = 1e10
+    edge = [[] for _ in range(v+1)]
+    # Adjacency list
+    for st, ed, val in edge_raw: edge[st].append((val, ed))
+    dist = [INF for _ in range(v+1)]
+    dist[start] = 0
+    hq = [(0, start)]
+    while len(hq):
+        val, st = heappop(hq)
+        if dist[st] < val : continue
+        for val_edge, ed in edge[st]:
+            if dist[ed] > dist[st] + val_edge:
+                dist[ed] = dist[st] + val_edge
+                heappush(hq, (dist[ed], ed))
+    return dist
+
+# Main
+if __name__ == '__main__':
+    input = sys.stdin.readline # fastio
+    V, E = map(int, input().split())
+    K = int(input())
+    edge = [tuple(map(int, input().split())) for _ in range(E)]
+    dist = dijkstra(V, K, edge)
+    print('\n'.join([str(i) if i!=1e10 else 'INF' for i in dist[1:]]))

graph/shortest_path/floyd_warshall.py

@@ -0,0 +1,31 @@
+# [BOJ 11404] 플로이드
+# link : https://www.acmicpc.net/problem/11657
+# tag : graph, floyd-warshall, shortest path
+# @subinium
+
+# Floyd-Warshall Algorthm
+# time complexity : O(V^3)
+def floyd_warshall(v, edge):
+    INF = 1e10
+    dist = [[INF for _ in range(v+1)] for _ in range(v+1)]     
+    for st, ed, val in edge : 
+        dist[st][ed] = min(dist[st][ed], val)
+
+    # mid(중간), st(출발), ed(도착) 순서 중요
+    for mid in range(1, v):
+        for st in range(1, v+1):
+            for ed in range(1, v+1):
+                dist[st][ed] = min(dist[st][ed], dist[st][mid]+dist[mid][ed])
+
+    # 자기자신으로 가는 루트
+    for i in range(v+1): dist[i][i] = INF 
+    return dist
+
+# Main
+if __name__ == '__main__':
+    n, m = int(input()), int(input())
+    edge = [tuple(map(int, input().split())) for _ in range(m)] # (from, to, time) 
+    dist = floyd_warshall(n, edge)
+    
+    for row in dist[1:]:
+        print(' '.join([str(int(i * (i!=1e10))) for i in row[1:]]))