Shortest Paths Problem. CS 362, Lecture 20. Today s Outline. Negative Weights

Transcription

1 Shortet Path Problem CS 6, Lecture Jared Saia Univerity of New Mexico Another intereting problem for graph i that of finding hortet path Aume we are given a weighted directed graph G = (V, E) with two pecial vertice, a ource and a target t We want to find the hortet directed path from to t In other word, we want to find the path p tarting at and ending at t minimizing the function w(p) = e p w(e) Today Outline Negative Weight The path that can be trodden i not the enduring and unchanging Path. The name that can be named i not the enduring and unchanging Name. - Tao Te Ching Single Source Shortet Path Dijktra Algorithm Bellman-Ford Algorithm We ll actually allow negative weight on edge The preence of a negative cycle might mean that there i no hortet path A hortet path from to t exit if and only if there i at leat one path from to t but no path from to t that touche a negative cycle In the following example, there i no hortet path from to t 5 t

2 Single Source Shortet Path SSSP Algorithm Single Source Shortet Path (SSSP) i a more general problem SSSP i the following problem: find the hortet path from the ource vertex to every other vertex in the graph The problem i olved by finding a hortet path tree rooted at the vertex that contain all the deired hortet path A hortet path tree i not a MST Each vertex v in the graph will tore two value which decribe a tentative hortet path from to v dit(v) i the length of the tentative hortet path between and v pred(v) i the predeceor of v in thi tentative hortet path The predeceor pointer automatically define a tentative hortet path tree 6 SSSP Algorithm Defn We ll now go over ome algorithm for SSSP on directed graph. Thee algorithm will work for undirected graph with light modification In particular, we mut pecifically prohibit alternating back and forth acro the ame undirected negative-weight edge Like for graph traveral, all the SSSP algorithm will be pecial cae of a ingle generic algorithm Initially we et: dit() =, pred() = NULL For every vertex v, dit(v) = and pred(v) = NULL 5

3 Relaxation Correctne We call an edge (u, v) tene if dit(u) + w(u, v) < dit(v) If (u, v) i tene, then the tentative hortet path from to v i incorrect ince the path to u and then (u, v) i horter Our generic algorithm repeatedly find a tene edge in the graph and relaxe it If there are no tene edge, our algorithm i finihed and we have our deired hortet path tree The correctne of the relaxation algorithm follow directly from three imple claim The run time of the algorithm will depend on the way that we make choice about which edge to relax Relax Claim Relax(u,v){ dit(v) = dit(u) + w(u,v); pred(v) = u; If dit(v), then dit(v) i the total weight of the predeceor chain ending at v: pred(pred(v)) pred(v) v. Thi i eay to prove by induction on the number of edge in the path from to v. (left a an exercie) 9

4 Claim Generic SSSP If the algorithm halt, then dit(v) w( v) for any path v. Thi i eay to prove by induction on the number of edge in the path v. (which you will do in the hw) We haven t yet aid how to detect which edge can be relaxed or what order to relax them in The following Generic SSSP algorithm anwer thee quetion We will maintain a bag of vertice initially containing jut the ource vertex Whenever we take a vertex u out of the bag, we can all of it outgoing edge, looking for omething to relax Whenever we uccefully relax an edge (u, v), we put v in the bag Claim InitSSSP The algorithm halt if and only if there i no negative cycle reachable from. The only if direction i eay if there i a reachable negative cycle, then after the firt edge in the cycle i relaxed, the cycle alway ha at leat one tene edge. The if direction follow from the fact that every relaxation tep reduce either the number of vertice with dit(v) = by or reduce the um of the finite hortet path length by ome poitive amount. InitSSSP(){ dit() = ; pred() = NULL; for all vertice v!= { dit(v) = infinity; pred(v) = NULL; 5

5 GenericSSSP Diktra Algorithm GenericSSSP(){ InitSSSP(); put in the bag; while the bag i not empty{ take u from the bag; for all edge (u,v){ if (u,v) i tene{ Relax(u,v); put v in the bag; If we implement the bag a a heap, where the key of a vertex v i dit(v), we obtain Dijktra algorithm Dijktra algorithm doe particularly well if the graph ha no negative-weight edge In thi cae, it not hard to how (by induction, of coure) that the vertice are canned in increaing order of their hortet-path ditance from It follow that each vertex i canned at mot once, and thu that each edge i relaxed at mot once 6 Generic SSSP Dijktra Algorithm Jut a with graph traveral, uing different data tructure for the bag give u different algorithm Some obviou choice are: a tack, a queue and a heap Unfortunately if we ue a tack, we need to perform Θ( E ) relaxation tep in the wort cae (an exercie for the diligent tudent) The other poibilitie are more efficient Since the key of each vertex in the heap i it tentative ditance from, the algorithm perform a DecreaeKey operation every time an edge i relaxed Thu the algorithm perform at mot E DecreaeKey Similarly, there are at mot V Inert and ExtractMin operation Thu if we tore the vertice in a Fibonacci heap, the total running time of Dijktra algorithm i O( E + V log V ) 9

6 Negative Edge Bellman-Ford Thi analyi aume that no edge ha negative weight The algorithm given here i till correct if there are negative weight edge but the wort-cae run time could be exponential The algorithm in our text book give incorrect reult for graph with negative edge (which they make clear) If we replace the bag in the GenericSSSP with a queue, we get the Bellman-Ford algorithm Bellman-Ford i efficient even if there are negative edge and it can be ued to quickly detect the preence of negative cycle If there are no negative edge, however, Dijktra algorithm i fater than Bellman-Ford Example Analyi 9 Four phae of Dijktra algorithm run on a graph with no negative edge. At each phae, the haded vertice are in the heap, and the bold vertex ha jut been canned. The bold edge decribe the evolving hortet path tree. 9 The eaiet way to analyze thi algorithm i to break the execution into phae Before we begin the alg, we inert a token into the queue Whenever we take the token out of the queue, we begin a new phae by jut reinerting the token into the queue The -th phae conit entirely of canning the ource vertex The algorithm end when the queue contain only the token

7 Invariant Analyi A imple inductive argument (left a an exercie) how the following invariant: At the end of the i-th phae, for each vertex v, dit(v) i le than or equal to the length of the hortet path v coniting of i or fewer edge Since a hortet path can only pa through each vertex once, either the algorithm halt before the V -th phae or the graph contain a negative cycle In each phae, we can each vertex at mot once and o we relax each edge at mot once Hence the run time of a ingle phae i O( E ) Thu, the overall run time of Bellman-Ford i O( V E ) 6 Example Book Bellman-Ford d a b e d a f c b e 9 d 6 a f c b e d f a f 6 c a b e 9 d c b e Four phae of Bellman-Ford algorithm run on a directed graph with negative edge. Node are taken from the queue in the order a b c d f b a e d d a, where i the token. Shaded vertice are in the queue at the end of each phae. The bold edge decribe the evolving hortet path tree. f c 5 Now that we undertand how the phae of Bellman-Ford work, we can implify the algorithm Intead of uing a queue to perform a partial BFS in each phae, we will jut can through the adjacency lit directly and try to relax every edge in the graph Thi will be much cloer to how the textbook preent Bellman- Ford The run time will till be O( V E ) To how correctne, we ll have to how that are earlier invariant hold which can be proved by induction on i

8 Book Bellman-Ford All-Pair Shortet Path Book-BF(){ InitSSSP(); repeat V time{ for every edge (u,v) in E{ if (u,v) i tene{ Relax(u,v); for every edge (u,v) in E{ if (u,v) i tene, return Negative Cycle For the ingle-ource hortet path problem, we wanted to find the hortet path from a ource vertex to all the other vertice in the graph We will now generalize thi problem further to that of finding the hortet path from every poible ource to every poible detination In particular, for every pair of vertice u and v, we need to compute the following information: dit(u, v) i the length of the hortet path (if any) from u to v pred(u, v) i the econd-to-lat vertex (if any) on the hortet path (if any) from u to v Take Away Example Dijktra algorithm and Bellman-Ford are both variant of the GenericSSSP algorithm for olving SSSP Dijktra algorithm ue a Fibonacci heap for the bag while Bellman-Ford ue a queue Dijktra algorithm run in time O( E + V log V ) if there are no negative edge Bellman-Ford run in time O( V E ) and can handle negative edge (and detect negative cycle) For any vertex v, we have dit(v, v) = and pred(v, v) = NULL If the hortet path from u to v i only one edge long, then dit(u, v) = w(u v) and pred(u, v) = u If there no hortet path from u to v, then dit(u, v) = and pred(u, v) = NULL 9

9 APSP ObviouAPSP The output of our hortet path algorithm will be a pair of V V array encoding all V ditance and predeceor. Many map contain uch a ditance matric - to find the ditance from (ay) Albuquerque to (ay) Ruidoo, you look in the row labeled Albuquerque and the column labeled Ruidoo We ll focu only on computing the ditance array The predeceor array, from which you would compute the actual hortet path, can be computed with only minor addition to the algorithm preented here ObviouAPSP(V,E,w){ for every vertex { dit(,*) = SSSP(V,E,w,); Lot of Single Source Analyi Mot obviou olution to APSP i to jut run SSSP algorithm V timne, once for every poible ource vertex Specifically, to fill in the ubarray dit(, ), we invoke either Dijktra or Bellman-Ford tarting at the ource vertex We ll call thi algorithm ObviouAPSP The running time of thi algorithm depend on which SSSP algorithm we ue If we ue Bellman-Ford, the overall running time i O( V E ) = O( V ) If all the edge weight are poitive, we can ue Dijktra intead, which decreae the run time to Θ( V E + V log V ) = O( V ) 5

10 Problem We d like to have an algorithm which take O( V ) but which can alo handle negative edge weight We ll ee that a dynamic programming algorithm, the Floyd Warhall algorithm, will achieve thi Note: the book dicue another algorithm, Johnon algorithm, which i aymptotically better than Floyd Warhall on pare graph. However we will not be dicuing thi algorithm in cla. 6