Undirected graph is a special case of a directed graph, with symmetric edges

Transcription

1 ijkstra s lgorithm 7-: omputing iven a directed weighted graph(all weights non-negative) and two verticesxand y, find the least-cost path fromxtoy in. Undirected graph is a special case of a directed graph, with symmetric edges Least-cost path may not be the path containing the fewest edges shortest path == least cost path path containing fewest edges = path containing fewest edges 7-: xample Shortest path path containing fewest edges 8 from to? 7-: xample Shortest path path containing fewest edges 8 from to :,,,, 7-: Single Source

2 ijkstra s lgorithm To find the shortest path from vertex x to vertex y, we need (worst case) to find the shortest path from x to all other vertices in the graph Why? 7-: Single Source To find the shortest path from vertex x to vertex y, we need (worst case) to find the shortest path from x to all other vertices in the graph To find the shortest path fromx toy, we need to find the shortest path fromxto all nodes on the path from x to y Worst case, all nodes will be on the path 7-: Single Source If all edges have unit weight : Single Source If all edges have unit weight, We can use readth irst Search to compute the shortest path S Spanning Tree contains shortest path to each node in the graph Need to do some more work to create & save S spanning tree When edges have differing weights, this obviously will not work 7-7: Single Source ivide the vertices into two sets: Vertices whose shortest path from the initial vertex is known Vertices whose shortest path from the initial vertex is not known Initially, only the initial vertex is known Move vertices one at a time from the unknown set to the known set, until all vertices are known 7-8: Single Source 8 6

3 ijkstra s lgorithm Start with the vertex 7-9: Single Source 8 6 Known vertices are circled in red We can now extend the known set by vertex 7-: Single Source 8 6 Why is it safe to add, with cost? 7-: Single Source 8 6 Why is it safe to add, with cost? istance istance istance

4 ijkstra s lgorithm ould we do better with a more roundabout path? 7-: Single Source 8 6 istance Why is it safe to add, with cost? ould we do better with a more roundabout path? No to get to any other node will cost at least No negative edge weights, can t do better than 7-: Single Source 8 6 istance We can now add another vertex to our known list... 7-: Single Source 8 6 istance How do we know that we could not get to cheaper than by going through?

5 ijkstra s lgorithm 7-: Single Source 8 6 istance How do we know that we could not get to cheaper than by going through? osts to get to osts at least to get anywhere from ost at least (+ = ) to get to through 7-6: Single Source 8 6 Next node we can add... istance 7-7: Single Source 8 6 (We also could have added for this step) Next vertex to add to Known... istance

6 ijkstra s lgorithm 6 7-8: Single Source 8 6 ost to add is 8 (through ) ost to add is (through ) istance 7-9: Single Source 8 6 istance Last node... 7-: Single Source 8 6 istance 6 We now know the length of the shortest path fromto all other vertices in the graph 7-: ijkstra s lgorithm

7 ijkstra s lgorithm 7 Keep a table that contains, for each vertex Is the distance to that vertex known? What is the best distance we ve found so far? Repeat: Pick the smallest unknown distance mark it as known update the distance of all unknown neighbors of that node Until all vertices are known 7-: ijkstra s lgorithm xample 7 7-: ijkstra s lgorithm xample 7 7-: ijkstra s lgorithm xample 7 7 Known istance false false false false false false Known istance true false 7 false false false false

8 ijkstra s lgorithm : ijkstra s lgorithm xample 7 7-6: ijkstra s lgorithm xample 7 7-7: ijkstra s lgorithm xample Known istance true false 7 false false 8 false true Known istance true false 7 false false 8 true true Known istance true false true false 6 true true

9 ijkstra s lgorithm : ijkstra s lgorithm xample 7 Known istance true true true false 6 true true : ijkstra s lgorithm Known istance true true true true 6 true true fter ijkstra s algorithm is complete: We know the length of the shortest path We do not know what the shortest path is How can we modify ijstra s algorithm to compute the path? 7-: ijkstra s lgorithm fter ijkstra s algorithm is complete: We know the length of the shortest path We do not know what the shortest path is How can we modify ijstra s algorithm to compute the path? Store not only the distance, but the immediate parent that led to this distance

10 ijkstra s lgorithm 7-: ijkstra s lgorithm xample 7-: ijkstra s lgorithm xample 7-: ijkstra s lgorithm xample 7-: ijkstra s lgorithm xample 7-: ijkstra s lgorithm xample Known ist Path false false false false false false false Known ist Path true false false false false false false Known ist Path true false true false false false false Known ist Path true false true true false 9 false 9 false 7

11 ijkstra s lgorithm 7-6: ijkstra s lgorithm xample 7-7: ijkstra s lgorithm xample 7-8: ijkstra s lgorithm xample 7-9: ijkstra s lgorithm Known ist Path true true true true false 9 false 9 false 7 Known ist Path true true true true false 9 false 8 true 7 Known ist Path true true true true false 9 true 8 true 7 Known ist Path true true true true true 9 true 8 true 7 iven the path field, we can construct the shortest path Work backward from the end of the path

12 ijkstra s lgorithm ollow the path pointers until the start node is reached 7-: ijkstra ode We can use a sentinel value in the path field of the initial node, so we know when to stop void ijkstra(dge [], int s, tablentry T[]) { int i, v; dge e; for(i=; i<.length; i++) { T[i].distance = Integer.MX_VLU; T[i].path = -; T[i].known = false; T[s].distance = ; for (i=; i <.length; i++) { v = minunknownvertex(t); T[v].known = true; for (e = [v]; e!= null; e = e.next) { if (T[e.neighbor].distance > T[v].distance + e.cost) { T[e.neighbor].distance = T[v].distance + e.cost; T[e.neighbor].path = v; 7-: minunknownvertex alculating minimum distance unknown vertex: int minunknownvertex(tablentry T[]) { int i; int minvertex = -; int ministance = Integer.MX_VLU; for (i=; i < T.length; i++) { if ((!T[i].known) && (T[i].distance < Ministance)) { minvertex = i; ministance = T[i].distance; return minvertex; 7-: ijkstra Running Time Time for initialization: for(i=; i<.length; i++) { T[i].distance = Integer.MX_VLU; T[i].path = -; T[i].known = false; T[s].distance = ; 7-: ijkstra Running Time Time for initialization: for(i=; i<.length; i++) { T[i].distance = Integer.MX_VLU; T[i].path = -; T[i].known = false; T[s].distance = ;

13 ijkstra s lgorithm Θ(V) 7-: ijkstra Running Time Total time for all calls to minunknownvertex, and setting T[v].known = true (for all iterations of the loop) for (i=; i <.length; i++) { v = minunknownvertex(t); < These two lines T[v].known = true; < for (e = [v]; e!= null; e = e.next) { if (T[e.neighbor].distance > T[v].distance + e.cost) { T[e.neighbor].distance = T[v].distance + e.cost; T[e.neighbor].path = v; 7-: ijkstra Running Time Total time for all calls to minunknownvertex, and setting T[v].known = true (for all iterations of the loop) for (i=; i <.length; i++) { v = minunknownvertex(t); < These two lines T[v].known = true; < for (e = [v]; e!= null; e = e.next) { if (T[e.neighbor].distance > T[v].distance + e.cost) { T[e.neighbor].distance = T[v].distance + e.cost; T[e.neighbor].path = v; Θ(V ) 7-6: ijkstra Running Time Total # of times the if statement will be executed: for (i=; i <.length; i++) { v = minunknownvertex(t); T[v].known = true; for (e = [v]; e!= null; e = e.next) { > if (T[e.neighbor].distance > > T[v].distance + e.cost) { > T[e.neighbor].distance = T[v].distance + e.cost; > T[e.neighbor].path = v; 7-7: ijkstra Running Time Total # of times the if statement will be executed: for (i=; i <.length; i++) { v = minunknownvertex(t); T[v].known = true; for (e = [v]; e!= null; e = e.next) { > if (T[e.neighbor].distance > > T[v].distance + e.cost) { > T[e.neighbor].distance = T[v].distance + e.cost; > T[e.neighbor].path = v; 7-8: ijkstra Running Time Total running time for all iterations of the inner for statement:

14 ijkstra s lgorithm for (i=; i <.length; i++) { v = minunknownvertex(t); T[v].known = true; > for (e = [v]; e!= null; e = e.next) { > if (T[e.neighbor].distance > > T[v].distance + e.cost) { > T[e.neighbor].distance = T[v].distance + e.cost; > T[e.neighbor].path = v; 7-9: ijkstra Running Time Total running time for all iterations of the inner for statement: for (i=; i <.length; i++) { v = minunknownvertex(t); T[v].known = true; > for (e = [v]; e!= null; e = e.next) { > if (T[e.neighbor].distance > > T[v].distance + e.cost) { > T[e.neighbor].distance = T[v].distance + e.cost; > T[e.neighbor].path = v; Θ(V +) WhyΘ(V +) and not justθ()? 7-: ijkstra Running Time Total running time: Sum of: Time for initialization Time for executing all calls tominunknownvertex Time for executing all distance / path updates =Θ(V +V +(V +)) = Θ(V ) 7-: Improving ijkstra an we do better thanθ(v ) or dense graphs, we can t do better To ensure that the shortest path to all vertices is computed, need to look at all edges in the graph dense graph can haveθ(v ) edges or sparse graphs, we can do better Where should we focus our attention? 7-: Improving ijkstra an we do better thanθ(v ) or dense graphs, we can t do better To ensure that the shortest path to all vertices is computed, need to look at all edges in the graph dense graph can haveθ(v ) edges

15 ijkstra s lgorithm or sparse graphs, we can do better Where should we focus our attention? inding the unknown vertex with minimum cost! 7-: Improving ijkstra To improve the running time of ijkstra: Place all of the vertices on a min-heap Key value for min-heap = distance of vertex from initial While min-heap is not empty: Pop smallest value off min-heap Update table Problems with this method? 7-: Improving ijkstra To improve the running time of ijkstra: Place all of the vertices on a min-heap Key value for min-heap = distance of vertex from initial While min-heap is not empty: Pop smallest value off min-heap Update table Problems with this method? When we update the table, we need to rearrange the heap 7-: Rearranging the heap Store a pointer for each vertex back into the heap When we update the table, we need to do a decrease-key operation ecrease-key can take up to time O(lgV). (xamples!) 7-6: Rearranging the heap Total time: O(V)remove-mins O(V lgv) O() dercrease-keys O( lg V) Total time: O(V lgv +lgv) O(lgV) 7-7: Improving ijkstra Store vertices in heap When we update the table, we need to rearrange the heap

16 ijkstra s lgorithm 6 lternate Solution: When the cost of a vertex decreases, add a new copy to the heap 7-8: Improving ijkstra reate a new priority queue, add start node While the queue is not empty: Remove the vertexv with the smallest distance in the heap Ifv is not known Markv as known or each neigborw ofv If distance[w] distance[v] + cost((v,w)) Set distance[w] = distance[v] + cost((v,w)) dd w to priority queue with priority distance[w] 7-9: Improved ijkstra Time ach vertex can be added to the heap once for each incoming edge Size of the heap can then be up toθ() inserts, on heap that can be up to size delete-mins, on heap that can be upto to size Total: Θ(lg) Θ(lgV) 7-6: Improved? ijkstra Time on t use priority queue, running time isθ(v ) o use a prioroty queue, running time isθ(lg) Which is better? 7-6: Improved? ijkstra Time on t use priority queue, running time isθ(v ) o use a prioroty queue, running time isθ(lg) Which is better? or dense graphs, ( Θ(V )),Θ(V ) is better or sparse graphs ( Θ(V)), Θ( lg ) is better 7-6: Improved! ijkstra Time If we use a data structre called a ibonacci heap instead of a standard heap, we can implement decrease-key in constant time (on average). Total time: O(V)remove-mins O(V lgv)

17 ijkstra s lgorithm 7 O() dercrease-keys O() (each decrease key takes O() on average) Total time: O(V lgv +) 7-6: Negative dges What if our graph has negative-weight edges? Think of the cost of the edge as the amount of energy consumed for a segment of road downhill segment could have negative energy consumed for a hybrid Will ijkstra s algorithm still work correctly? xamples 7-6: Negative dges What happens if there is a negative-weight cycle? What does the shortest path even mean? 7-6: Negative dges What happens if there is a negative-weight cycle? What does the shortest path even mean? inding shortest paths in graphs that contain negative edges, assume that there are no negative weight cycles Hybrid example 7-66: ll-source What if we want to find the shortest path from all vertices to all other vertices? How can we do it? 7-67: ll-source What if we want to find the shortest path from all vertices to all other vertices? How can we do it? Run ijktra s lgorithmv times How long will this take? What about negative edges? 7-68: ll-source What if we want to find the shortest path from all vertices to all other vertices? How can we do it? Run ijktra s lgorithmv times How long will this take? Θ(Vlg) (using priority queue)

18 ijkstra s lgorithm 8 for sparse graphs,θ(v lgv) for dense graphs,θ(v lgv) Θ(V ) (not using a priority queue) What about negative edges? 7-69: loyd s lgorithm oesn t work correctly lternate solution to all pairs shortest path YieldsΘ(V ) running time for all graphs Works for graphs with negative edges an detect negative-weight cycles 7-7: loyd s lgorithm Vertices numbered from..(n-) k-path from vertex v to vertex u is a path whose intermediate vertices (other than v and u) contain only vertices numbered less than or equal tok --path is a direct link 7-7: k-path xamples 7 Shortest --path from to : Shortest -path from to : Shortest -path from to : Shortest -path from to : Shortest -path from to : 7-7: k-path xamples 7

19 ijkstra s lgorithm 9 Shortest --path from to : 7 Shortest -path from to : 7 Shortest -path from to : 6 Shortest -path from to : 6 Shortest -path from to : 6 Shortest -path from to : 7-7: loyd s lgorithm Shortestn-path = Shortest path Shortest --path: if there is no direct link ost of the direct link, otherwise 7-7: loyd s lgorithm Shortestn-path = Shortest path Shortest --path: if there is no direct link ost of the direct link, otherwise If we could use the shortestk-path to find the shortest(k +) path, we would be set 7-7: loyd s lgorithm Shortest k-path from v to u either goes through vertex k, or it does not If not: If so: Shortestk-path = shortest(k )-path Shortestk-path = shortestk path fromv to k, followed by the shortestk path fromk tow 7-76: loyd s lgorithm If we had the shortestk-path for all pairs (v,w), we could obtain the shortest k +-path for all pairs or each pairv,w, compare: length of thek-path fromv to w length of thek-path fromv to k appended to the k-path fromk tow Set thek+ path fromv tow to be the minimum of the two paths above 7-77: loyd s lgorithm Let k [v,w] be the length of the shortestk-path fromv to w.

20 ijkstra s lgorithm [v,w] = cost of arc fromv to w ( if no direct link) k [v,w] = MIN( k [v,w], k [v,k]+ k [k,w]) reate, use to create, use to create, and so on until we have n 7-78: loyd s lgorithm Use a doubly-nested loop to create k from k Use the same array to store k and k just overwrite with the new values mbed this loop in a loop from..k 7-79: loyd s lgorithm loyd(dge [], int [][]) { int i,j,k Initialize, [i][j] = cost from i to j for (k=; k<.length; k++; for(i=; i<.length; i++) for(j=; j<.length; j++) if (([i][k]!= Integer.MX_VLU) && ([k][j]!= Integer.MX_VLU) && ([i][j] > ([i,k] + [k,j]))) [i][j] = [i][k] + [k][j] 7-8: loyd s lgorithm We ve only calculated the distance of the shortest path, not the path itself We can use a similar strategy to the PTH field for ijkstra to store the path We will need a - array to store the paths: P[i][j] = last vertex on shortest path from i to j