All-Pairs Shortest Paths. All-Pairs Shortest Paths (Ch. 25) Overview of Dynamic Programming. Overview of Dynamic Programming. Slow-APSP Algorithm

Transcription

1 All-Pairs Shortest Paths (Ch. ) The all-pairs shortest path problem (APSP) input: a directed graph G = (V, E) with edge weights goal: find a minimum weight (shortest) path between every pair of vertices in V (sometimes we only want the cost of these paths) Solution : run Dijkstra s algorithm V times, once with each v V as the source node (requires no negative-weight edges in E) If G is dense array implementation of priority Q O(V V ) = O (V ) time If G is sparse binary heap implementation of priority Q O(V ((V + E) logv)) = O(V logv + VElogV) time All-Pairs Shortest Paths Solution : run the Bellman-Ford algorithm V times (negative edge weights allowed), once from each vertex. O(V E), which on a dense graph is O(V ) Solution : Use an algorithm designed for the APSP problem. (we will see a few) E.g., Floyd-Warshall Algorithm introduces a dynamic programming technique allows negative-weight edges, but no negative-weight cycles uses adjacency matrix representation of G = (V, E) Overview of Dynamic Programming o Some recursive divide-and-conquer algorithms are inefficient they solve the same sub-problems multiple times. o Dynamic programming is a technique that can be used to cut down on the inefficiency (solve each sub-problem just once). o Typically, applied to optimization problems Two approaches to dynamic programming: Method : Top-Down Recursive Approach (memo-ization) start with recursive divide-and-conquer algorithm keep top-down approach of original algorithm save solutions to sub-problems in a table (can be lots of storage) only recurse on a sub-problem if the solution not in table. Overview of Dynamic Programming Method : Bottom-Up iterative approach start with recursive divide-and-conquer algorithm figure out the dependencies between the sub-problems (which solutions are needed for each sub-problem) re-write the algorithm so it solves the sub-problems in the correct order (so we won t have to save as many solutions in the table). The divide-and-conquer paradigm. divide problem into sub-problems. solve the sub-problems, generally recursively. combine sub-problems to get the answer Example: Merge-sort T(n) = T(n/) + O(n) Slow-APSP Algorithm Input: Adjacency matrix A Observation: When G contains no Output: Shortest path matrix D (n) negative-weight cycles, all shortest paths consist of at most n edges Solution for D: Define D (k) [i, j] = d (k) ij as the minimum weight of any path from vertex i to vertex j, consisting of at most k edges D () = A, original adjacency matrix (only paths are single edges) D (n-) the matrix we want to compute D (k) s elements are: D (k) [i, j] = d (k) ij = min(d (k-) ij, d (k-) ik + d (k-) kj ) Slow-APSP Algorithm Idea: Find all vertices reachable in two hops, D (), save the matrix, and use it to find all vertices reachable in three hops, D (), save the matrix, and use it to find all vertices reachable in four hops, D (), and so on until we find D (n-). This matrix will contain the shortest path between every pair of vertices in the graph. D () = A =

2 Computing D (m) from D (m-) Extend-Shortest Paths (D, A). n = rows[d]. let D = (d ij ) be an n x n matrix. for i = to n do. for j = to n do. d ij =. for k = to n do. d ij = min (d ij, d ik + a kj ). return D The above algorithm is very closely related to an algorithm for matrix multiplication. Slow Dynamic-Programming Solution Slow-APSP (A). n = rows[a]. D () = A. for m = to n - do. D (m) = Extend-Shortest-Paths(D (m-), A). return D (n-) Extend-Shortest Paths (D, A). n = rows[d]. let D = (d ij ) be an n x n matrix. for i = to n do. for j = to n do. d ij =. for k = to n do. d ij = min (d ij, d ik + a kj ). return D Matrix multiplication Matrix-Multiply (A, B). n = rows[a]. let C = be an n x n matrix. for i = to n do. for j = to n do. c ij =. for k = to n do. c ij = c ij + a ik b kj. return C Recall how matrix multiplication works. This algorithm is structurally similar to ESP. Other features they have in common include running time and associativity of operations. 9 Operation of Slow-APSP Algorithm D () = A = D () D () Operation of Slow-APSP Algorithm - D () = A = , D () =,, - - -, Operation of Slow-APSP Algorithm D () = NC - -

3 Operation of Slow-APSP Algorithm Running Time of Slow-APSP D () = NC NC NC - - Lines & of Slow-APSP: V iterations For each iteration there is a call to Extend-Shortest-Paths Lines of ESP: V time for triply-nested for loops Overall running time = (( V ) V ) = O(V ) Hence, the name... However, the running time of Slow-APSP can be improved if we remember that we are not interested in all the D (n-) matrices: we only need matrix D (n-). Can we compute this faster? Faster-APSP Recall that, in the absence of negative-weight cycles, D (m) = D (n-) for all m n. Therefore, we can compute D (n-) with only lg(n-) calls to ESP by computing the sequence D () = A, D () = A A, D () = A A, D ( lg(n-) ) = A lg(n-) - A lg(n-) - Since lg(n-) = n, the final product is equal to D (n-) The faster APSP algorithm uses the technique of repeated squaring. Faster Dynamic-Programming Solution Faster-APSP (A). n = rows[a]. D () = A. m =. while m < n - do. D (m) = Extend-Shortest-Paths(D (m), D (m) ). m = m. return D (m) Extend-Shortest Paths (D, A). n = rows[d]. let D = (d ij ) be an n x n matrix. for i = to n do. for j = to n do. d ij =. for k = to n do. d ij = min (d ij, d ik + a kj ). return D Operation of Faster-APSP Algorithm - D () = A = , D () =,, - - -, Operation of Faster-APSP Algorithm - - :, : - - : D () = :, : : NC Compare this result to the one we obtained for the D () matrix with Slow-APSP. The changes - in the last iteration correspond - exactly to the changes in the last iterations with that algorithm

4 Running Time of Faster-APSP Lines of Faster-APSP: lg(v-) iterations For each iteration there is a call to Extend-Shortest-Paths Lines of ESP: V time for triply-nested for loops Overall running time = ( lg(v-) V ) = O(V lgv) Idea: Find all vertices reachable using intermediate nodes in the range... (D () ), save the matrix, and use it to find all vertices reachable using intermediate vertices in the range... (D () ), save the matrix, and use it to find all vertices reachable using intermediate vertices in the range... (D () ), and so on until we find D (n). This matrix will contain the shortest path between every pair of vertices in the graph. 9 Input: Adjacency matrix A Observation: When G contains no Output: Shortest path matrix D (n) negative-weight cycles, all shortest paths consist of at most n edges Assumes vertices are numbered to V Relies on the Optimal Substructure Property: All sub-paths of a shortest path are shortest paths. Solution for D: Define D (k) [i, j] = d (k) ij as the minimum weight of any path from vertex i to vertex j, such that all intermediate vertices are in {,,,..., k} D () = A, original adjacency matrix (only paths are single edges) D (n) the matrix we want to compute D (k) s elements are: D (k) [i, j] = d (k) ij = min(d (k-) ij, d (k-) ik + d (k-) kj ) Recursive Solution for D (n) D (k) [i, j] = d ij (k) = min(d ij (k-), d ik (k-) + d kj (k-) ) d ik (k-) i k d ij (k-) d kj (k-) The only intermediate nodes on these paths are in the set of vertices {,,,..., k-} j Use adjacency matrix A for G = (V, E): w(i, j) if (i,j) E A[i, j] = a ij = if i = j if i j and (i, j) E Floyd-Warshall-APSP(A). n = rows[a]. D () = A. for k = to n do. for i = to n do. for j = to n do. d ij (k) = min (d ij (k-), d ik (k-) + d kj (k-) ). return D (n)

5 Operation of D () = A = D () D () D () D () = A = D () = , D () = D () = D () = D () = ,,,,,,

6 Running Time of FW-APSP Lines : V time for triply-nested for loops Overall running time = = θ(v ) Additionally, the code is tight, with no elaborate data structures and so the constant hidden in the θ-notation is small.