Shortest Paths

Weighted Graphs In a weighted graph, each edge has an associated numerical value, called the weight of the edge Edge weights may represent, distances, costs, etc. Example: A vertex represents an airport and stores the three-letter airport code An edge represents a flight route between two airports and stores the mileage of the route ORD PVD MIA DFW SFO LAX LGA HNL 849 802 1387 1743 1843 1099 1120 1233 337 2555 142 Los Angeles Chicago Providence San Francisco Honolulu Dallas Miami New York

Shortest Paths The problem: Weight of the path P sum of the weights of all the edges on the path P Shortest path path with smallest weight The problem: Given a weighted graph and two vertices u and v, we want to find a path of minimum total weight (shortest path) between u and v.

Shortest Path Properties Property 1: A sub-path of a shortest path is itself a shortest path Property 2: There is a tree of shortest paths from a start vertex to all the other vertices Example: Tree of shortest paths from Providence ORD PVD MIA DFW SFO LAX LGA HNL 849 802 1387 1743 1843 1099 1120 1233 337 2555 142 1205 Providence Los Angeles Chicago San Francisco Honolulu Dallas Miami New York

The Distance of a Shortest Path Case 1: The graph may have negative edges but no negative cycles. The shortest distance from s to t can be computed. A B s t -3 1 8 d(s,t)=6 Case 2: The graph contains negative weight cycles, and a path from s to t includes an edge on a negative weight cycle. The shortest path distance is -. 1 s 1 8 t d(s,t)=-  A B -3

Shortest Path Algorithms Dijkstra’s algorithm does NOT allow negative edges. Uses a greedy heuristic. undirected/directed graph Bellman-Ford’s and Floyd’s algorithms work correctly for any graph and can detect negative cycles. Must be directed graph if negative edges are included.

Shortest Path Algorithms Dijkstra’s algorithm does NOT allow negative edges. Uses a greedy heuristic. undirected/directed graph Bellman-Ford’s and Floyd’s algorithms work correctly for any graph and can detect negative cycles. Must be directed graph if negative edges are included. We will study Dijkstra’s algorithm only. The others are beyond the scope of this course

Dijkstra’s Algorithm The distance of a vertex v from a vertex s is the length of a shortest path between s and v Dijkstra’s algorithm (pronounced dyke-stra) computes the distances of all the vertices from a given start vertex s Assumptions: the graph is connected the edge weights are nonnegative

Dijkstra’s Algorithm d(u) We grow a “cloud” of vertices, beginning with s and eventually covering all the vertices We store with each vertex u a label d(u) representing the distance of u from s in the subgraph consisting of the cloud and its adjacent vertices At each step We add to the cloud the vertex u outside the cloud with the smallest distance label, d(u) We update the labels d(.) of the vertices adjacent to u s s d(u) 8 A 4 8 A 4 2 2 2 8 7 2 1 4 8 7 1 3 B C D B C D 9  3 9 5  3 11 2 2 E F 5 E F 5

Dijkstra’s Algorithm - Edge Relaxation d(u) = 50 Consider an edge e = (u,z) such that u is the vertex most recently added to the cloud z is not in the cloud The relaxation of edge e updates distance d(z) as follows: d(z) := min{d(z),d(u) + weight(e)} 10 d(z) = 75 e u s z d(u) = 50 10 d(z) = 60 u e s z

Example C B A E D F 4 2 8  7 1 5 3 9 11

Example C B A E D F 3 2 7 5 8 4 1 9

Dijkstra’s Algorithm A priority queue stores the vertices outside the cloud (Key: distance, Element: vertex) Algorithm ShortestPath(G, v) Input A weighted graph G with nonnegative edge weights, and a start vertex v of G Output a label D[u] for each u of G , so that D[u] is the length of a shortest path from v to u in G Initialize D[v] := 0 , and D[u] :=  for every vertex u ≠ v Let a priority queue Q contain all the vertices of G using the D label as a key while Q is not empty do {pull a new vertex u into the cloud} u := Q.removeMin() for each vertex z adjacent to u such that z is in Q do {perform the relaxation on edge (u,z)} if D[u] + w((u,z)) < D[z] then D[z] := D[u] + w((u,z)) change to D[z] the key of vertex z in Q return the label D[u] of each vertex u

Analysis of Dijkstra’s Algorithm Inserting all the vertices in Q with their initial key value can be done in O(n log n) At each iteration of the while loop, we spend O(log n) time to remove vertex u from Q and O(degree (v) log n) time to perform the relaxation procedure on each edge //note that it takes log n to update D[z] in the heap The overall running time for the entire while loop is O(m log n) remember Sv degree(v) = 2m Dijkstra’s algorithm runs in O((n + m) log n) time provided the graph is represented by the adjacency list structure // the use of adjacency list allows us to step through the vertices adjacent to u during the relaxation step in time proportional to their number

Why It Doesn’t Work for Negative-Weight Edges Dijkstra’s algorithm is based on the idea that it adds vertices by increasing distance. If a node with a negative incident edge were to be added late to the cloud, it could mess up distances for vertices already in the cloud. A 8 4 6 7 5 4 B 7 C 1 D -8 5 9 2 5 E F C’s true distance is 1, but it is already in the cloud with d(C)=5!