Data Structures & Algorithms Shortest Paths Richard Newman based on book by R. Sedgewick and slides by S. Sahni

Minimum Cost Path Weighted, digraph G, or network Directed simple path p from s to t Cost(p) = sum of edge weights on p Minimum cost path p from s to t in G such that no other path p' from s to t in G has cost(p') < cost(p)

Minimum Cost Path s = 1, t = 10 What is minimum cost path?

A Spanning Tree path cost = 28 Is there a cheaper path?

A Spanning Tree path cost = 25 Is there a cheaper path?

A Spanning Tree path cost = 24 Is there a cheaper path?

Shortest Path Problems No negative weight edges allowed! s-t shortest path – Single source, destination – Fastest route to Epcot Single Source Shortest Path – Best routes from A to anywhere All Pairs Shortest Paths – Routing tables in network nodes

Shortest Path Algorithms Dijkstra's Algorithm Floyd's Algorithm Bellman-Ford Algorithm

Shortest Path Algorithms Dijkstra's Algorithm Floyd's Algorithm Bellman-Ford Algorithm

Dijkstra's Algorithm Very similar to Prim's algorithm Differences are that – Paths form a rooted tree (whereas MST is not rooted) – Graph is directed (not undirected) Grow known shortest paths from source one edge at a time Priority of edge is different

Dijkstra's Algorithm Set Known nodes K = {s} Set dist(s) = 0, dist(u) = ∞ for all other nodes u in G Set pred(s) = s, pred(u) = NULL for all other nodes u in G Set Seen nodes S = {neighbors of s} Set pred(u) = s for all nodes in S

Dijkstra's Algorithm While |K| < V Find nearest node v in S Add v to K For each edge (v,w) in E If dist(v) + cost(v,w) < dist(w) Add w to S Pred(w) = v dist(w) = dist(v) + cost(v,w)

Dijkstra's Algorithm s = 1 Grow SPT by adding node nearest to s Update best distances

Dijkstra's Algorithm Correct Builds shortest path tree (SPT) Always adds nearest seen node v Path takes into account all nodes in K No other node x not in K can be closer than v Hence no path through x could be shorter than the path we have to v

Dijkstra's Algorithm Complexity Initialization – O(V) Select next node – O(V) linear list Update dist, pred – O(E) total Selection done V-1 times Total time – O(V 2 + E) = O(V 2 ) Using linear list for S

Dijkstra's Algorithm Complexity MinHeap – O((V+E) lg V) V removals, E changes to S What if G is dense – E is O(V 2 )? Worse!! Fibonacci Heap – O(V lg V + E) Even better!

Dijkstra's Algorithm Solves single source shortest path Builds SPT For s-t shortest path, Just stop when t is added to K Also works for sink-trees (take edges in reverse direction)

Dijkstra's Algorithm Does NOT work with negative edge weights! (Violates assumption needed by greedy method) Can be used to solve all pairs shortest path Build SPT from each node Complexity of SSSP times V

Shortest Path Algorithms Dijkstra's Algorithm Floyd's Algorithm Bellman-Ford Algorithm

Shortest Path Algorithms Floyd's Algorithm Single source shortest paths Works like Warshall’s algorithm for reachability Except takes path costs into account

Floyd’s Algorithm Recall Warshall's Algorithm For each intermediate node i For each source s For each destination t s reaches t if s already reaches t or if s reaches i and i reaches t

Floyd’s Algorithm Now just track distances For each intermediate node i For each source s For each destination t cost(s,t) = lesser of cost(s,t) and cost(s,i) + cost(i,t)

Floyd’s Algorithm Complexity of Floyd’s algorithm: O(V 3 ) Dynamic Programming and Relaxation Build estimates Improve estimates (node relax) Converge

Floyd's Algorithm Consider paths through nodes numbered <1, <2, <3, etc

Floyd's Algorithm Paths through nodes numbered < better, worse

Floyd's Algorithm Paths through nodes numbered < = 61 >

Floyd's Algorithm Paths through nodes numbered <

Floyd's Algorithm Paths through nodes numbered <

Floyd's Algorithm Paths through nodes numbered <

Floyd's Algorithm Paths through nodes numbered <

Floyd’s Algorithm Update successor node when updating minimum cost path Method of choice for APSP for dense graphs Works even with negative weights But not with negative cycles! (can detect at least one)

Shortest Path Algorithms Dijkstra's Algorithm Floyd's Algorithm Bellman-Ford Algorithm

Shortest Path Algorithms Bellman-Ford Algorithm SSSP Compute best cost path by edge relaxation – checking all edges Essentially considers paths of increasing potential length

Bellman-Ford Algorithm Initialize: dist[t] = {0 if t==s, else infinity} pred[v] = NULL for all v For (i = 1 to V-1) For each edge e=(u,v) in E If (dist[u] + cost[e] < dist[v]) dist[v] = dist[u] + cost[e] pred[v] = u

Bellman-Ford Algorithm Consider paths of length <2, <3, etc. Adjacency matrix is paths of length <

Bellman-Ford Algorithm Edge (0,1) Enter here Leave here

Bellman-Ford Algorithm Edge (0,5) doesn’t help Edge (1,2)

Bellman-Ford Algorithm Edge (2,3)

Bellman-Ford Algorithm Edge (3,0)

Bellman-Ford Algorithm Edge (3,5)

Bellman-Ford Algorithm Edge (4,2)

Bellman-Ford Algorithm Edge (4,3)

Bellman-Ford Algorithm Edge (5,1)

Bellman-Ford Algorithm Edge (5,4)

Bellman-Ford Algorithm Well, that was ONE pass – need to do that V times!

Shortest Path Algorithms Dijkstra's Algorithm Floyd's Algorithm Bellman-Ford Algorithm