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

Transcription

1 S-6S- ijkstra s lgorithm -: omputing iven a directed weighted graph (all weights non-negative) and two vertices x and y, find the least-cost path from x to y 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 -: xample Shortest path path containing fewest edges 8 from to? -: xample Shortest path path containing fewest edges 8 from to :,,,, -: Single Source

2 S-6S- 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? -: 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 from x to y, we need to find the shortest path from x to all nodes on the path from x to y Worst case, all nodes will be on the path -: Single Source If all edges have unit weight... -6: 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 -: 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 -8: Single Source 8 6

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

4 S-6S- ijkstra s lgorithm ould we do better with a more roundabout path? -: 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 -: Single Source 8 6 istance We can now add another vertex to our known list... -: Single Source 8 6 istance How do we know that we could not get to cheaper than by going through?

5 S-6S- ijkstra s lgorithm -: 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 -6: Single Source 8 6 Next node we can add... istance -: Single Source 8 6 (We also could have added for this step) Next vertex to add to Known... istance

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

7 S-6S- ijkstra s lgorithm 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 -: ijkstra s lgorithm xample -: ijkstra s lgorithm xample -: ijkstra s lgorithm xample Known istance false false false false false false Known istance true false false false false false

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

9 S-6S- ijkstra s lgorithm 9-8: ijkstra s lgorithm xample Known istance true true true false 6 true true -9: 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? -: 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 S-6S- -: ijkstra s lgorithm xample -: ijkstra s lgorithm xample -: ijkstra s lgorithm xample -: ijkstra s lgorithm xample -: ijkstra s lgorithm xample ijkstra s lgorithm 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

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

12 S-6S- ijkstra s lgorithm ollow the path pointers until the start node is reached -: 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; -: 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; -: 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 = ; -: 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 S-6S- ijkstra s lgorithm Θ(V ) -: 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; -: 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 ) -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; -: 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; -8: ijkstra Running Time Total running time for all iterations of the inner for statement:

14 S-6S- 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; -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 Θ()? -: ijkstra Running Time Total running time: Sum of: Time for initialization Time for executing all calls to minunknownvertex Time for executing all distance / path updates = Θ(V + V + (V + )) = Θ(V ) -: 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? -: 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 S-6S- ijkstra s lgorithm or sparse graphs, we can do better Where should we focus our attention? inding the unknown vertex with minimum cost! -: 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? -: 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 -: 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(V ). (xamples!) -6: Rearranging the heap Total time: O(V ) remove-mins O(V lg V ) O() dercrease-keys O( lg V ) Total time: O(V lg V + lg V ) O( lg V ) -: Improving ijkstra Store vertices in heap When we update the table, we need to rearrange the heap

16 S-6S- ijkstra s lgorithm 6 lternate Solution: When the cost of a vertex decreases, add a new copy to the heap -8: Improving ijkstra reate a new priority queue, add start node While the queue is not empty: Remove the vertex v with the smallest distance in the heap If v is not known Mark v as known or each neigbor w of v 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] -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 ) Theta( lg V ) -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? -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 -6: ll-source What if we want to find the shortest path from all vertices to all other vertices? How can we do it? -6: ll-source

17 S-6S- ijkstra s lgorithm What if we want to find the shortest path from all vertices to all other vertices? How can we do it? Run ijktra s lgorithm V times How long will this take? -6: 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 lgorithm V times How long will this take? Θ(V lg ) (using priority queue) for sparse graphs, Θ(V lg V ) for dense graphs, Θ(V lg V ) Θ(V ) (not using a priority queue) -6: loyd s lgorithm lternate solution to all pairs shortest path Yields Θ(V ) running time for all graphs -66: 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 to k --path is a direct link -6: k-path xamples Shortest --path from to : Shortest -path from to : Shortest -path from to : Shortest -path from to : Shortest -path from to :

18 S-6S- ijkstra s lgorithm 8-68: k-path xamples Shortest --path from to : Shortest -path from to : Shortest -path from to : 6 Shortest -path from to : 6 Shortest -path from to : 6 Shortest -path from to : -69: loyd s lgorithm Shortest n-path = Shortest path Shortest --path: if there is no direct link ost of the direct link, otherwise -: loyd s lgorithm Shortest n-path = Shortest path Shortest --path: if there is no direct link ost of the direct link, otherwise If we could use the shortest k-path to find the shortest (k + ) path, we would be set -: loyd s lgorithm Shortest k-path from v to u either goes through vertex k, or it does not If not: Shortest k-path = shortest (k )-path If so: Shortest k-path = shortest k path from v to k, followed by the shortest k path from k to w -: loyd s lgorithm

19 S-6S- ijkstra s lgorithm 9 If we had the shortest k-path for all pairs (v,w), we could obtain the shortest k + -path for all pairs or each pair v, w, compare: length of the k-path from v to w length of the k-path from v to k appended to the k-path from k to w Set the k + path from v to w to be the minimum of the two paths above -: loyd s lgorithm Let k [v, w] be the length of the shortest k-path from v to w. [v, w] = cost of arc from v 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 -: 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 -: 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] -6: 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