Algorithms (2IL15) Lecture 6 ALL-PAIRS SHORTEST PATHS w 1,k a i,1 - PowerPoint PPT Presentation

TU/e Algorithms (2IL15) – Lecture 6 Algorithms (2IL15) – Lecture 6 ALL-PAIRS SHORTEST PATHS w 1,k … a i,1 … a i,n = b i,k w n,k 1

TU/e Algorithms (2IL15) – Lecture 6 Previous lecture: Single-Source Shortest Paths Dijkstra’s algorithm  works only for non-negative edge weights  running time Θ ( | V | log | V | + | E | ) Bellman-Ford algorithm  can handle negative edge weights, works even for negative-weight cycles  running time Θ ( | V | ∙ | E | ) Today: the All-Pairs Shortest-Path Problem 2

TU/e Algorithms (2IL15) – Lecture 6 All-Pairs Shortest Paths If we only have non-negative edge-weights: Run Dijkstra’s algorithm |V| times, once with each vertex as source  running time Θ ( | V 2 | log | V | + |V| ∙ | E | ) What to do if we also have negative edge weights? 3

TU/e Algorithms (2IL15) – Lecture 6 adjacency-matrix representation weighted, directed graph 1 2 3 4 5 6 7 1 0 2 v 4 − 2 v 3 2 0 4 1 v 1 0 -2 3 1 2 v 5 2 0 1 4 v 6 0 5 4 2.3 1 2 0 2.3 6 v 2 0 7 v 7 M [ i,j ] = 0 if i = j w(v i ,v j ) if i ≠ j and edge (v i ,v j ) exists; w(v i ,v j ) is weight of (v i ,v j ) 8 if edge (v i ,v j ) does not exist 4

TU/e Algorithms (2IL15) – Lecture 6 Warm-up/Recap: Bellman-Ford via dynamic programming 5

TU/e Algorithms (2IL15) – Lecture 6 5 steps in designing dynamic-programming algorithms 1. define subproblems [#subproblems] 2. guess first choice [#choices] 3. give recurrence for the value of an optimal solution [time/subproblem treating recursive calls as Θ (1))] i. define subproblem in terms of a few parameters ii. define variable m [..] = value of optimal solution for subproblem iii. relate subproblems by giving recurrence for m [..] 4. algorithm: fill in table for m [..] in suitable order (or recurse & memoize) 5. solve original problem Running time: #subproblems * time/subproblem Correctness: (i) correctness of recurrence: relate OPT to recurrence (ii) correctness of algorithm: induction using (i) 6

TU/e Algorithms (2IL15) – Lecture 6 Single-Source Shortest Paths: structure of optimal solution V = { v 1 , v 2 , … , v n } s = v 1 shortest path from s to v i with m edges shortest path from s to v j with m−1 edges v j v i v 1 Subproblem: For each vertex v i compute shortest path from s to v i with at most m edges Define variable: L(i,m) = length of shortest path from s to v i with at most m edges Recursive formula: if i =1 and m = 0 0 8 Note: here L ( i,m ) = if 1 < i ≤ n − 1 and m = 0 adjacency matrix, min { L ( j , m −1) + w ( v j , v i ) } if 0 < m ≤ n −1 but Bellman-Ford 1≤ j ≤ n uses adjacency list 7

TU/e Algorithms (2IL15) – Lecture 6 Single-Source Shortest Paths: dynamic-programming solution Recursive formula: 0 if i =1 and m = 0 L ( i,m ) = if 1 < i ≤ n − 1 and m = 0 8 min { L ( j , m −1) + w ( v j , v i ) } if 0 < m ≤ n − 1 1≤ j ≤ n m 0 n-1 0 1 8 8 8 8 solution to original problem i is in last column 8 8 8 8 8 n 8

TU/e Algorithms (2IL15) – Lecture 6 Single-Source Shortest Paths: dynamic-programming solution Recursive formula: 0 if i =1 and m = 0 L ( i,m ) = if 1 < i ≤ n − 1 and m = 0 8 min { L ( j , m −1) + w ( v j , v i ) } if 0 < m ≤ n − 1 1≤ j ≤ n SSSP-DynamicProgramming ( G,s ) // G = ( V,E ) with V = { v 1 , v 2 , … , v n } and s = v 1 L [ 1,0 ] ← 0 1. O(n 3 ) running time: for i ← 2 to n do L [ i,0 ] ← 8 2. O(n 2 ) storage: for m ← 1 to n − 1 3. Note: Bellman-Ford do for i ← 1 to n 4. actually runs in O(|V||E|) time using do L [ i,m ] ← min { L ( j , m −1) + w ( v j , v i ) } 5. 1≤ j ≤ n O(|V|) space. How to check if a negative- after algorithm: L [ i,n-1 ] = δ (v 1 ,v i ) for all i weight cycle is reachable? 9

TU/e Algorithms (2IL15) – Lecture 6 Now adapt to all-pairs shortest paths V = { v 1 , v 2 , … , v n } shortest path from v i to v k with m edges shortest path from v i to v j with m−1 edges v j v k v i Subproblem: For each pair v i ,v k compute shortest path from v i to v k with at most m edges Define variable: L(i,k,m) = length of shortest path from v i to v k with at most m edges Recursive formula: 0 if i = k and m = 0 L ( i,k,m ) = if i ≠ k and m = 0 8 min { L ( i , j , m −1) + w ( v j , v k ) } if 0 < m ≤ n −1 1≤ j ≤ n 10

TU/e Algorithms (2IL15) – Lecture 6 All-Pairs Shortest Paths: dynamic-programming solution Recursive formula: 0 if i = k and m = 0 L ( i,k,m ) = if i ≠ k and m = 0 8 min { L ( i , j , m −1) + w ( v j , v k ) } if 0 < m ≤ n −1 1≤ j ≤ n Slow-All-Pairs-Shortest-Paths ( G,s ) O(n 4 ) running time: for i ← 1 to n 1. O(n 3 ) storage: do for k ← 1 to n 2. do L [ i,k,0 ] ← 8 3. for i ← 1 to n do L [ i,i,0 ] ← 0 4. for m ← 1 to n − 1 5. NB: still need to check for do for i ← 1 to n 6. negative-weight cycles do for k ← 1 to n 7. do L [ i,k,m ] ← min { L ( i , j , m −1) + w ( v j , v k ) } 8. 1≤ j ≤ n 11

TU/e Algorithms (2IL15) – Lecture 6 All-Pairs Shortest Paths: slightly different formulation New recursive formula: L ( i,k,m ) = w ( v j , v k ) if m = 1 min { L ( i , j , m −1) + w ( v j , v k ) } if 1 < m ≤ n −1 1≤ j ≤ n Slow-All-Pairs-Shortest-Paths ( G,s ) L ← W // W = matrix of edge weights : W [ i,j ] = w ( v j , v j ) 1. for m ← 2 to n − 1 2. do L ← Extend -Shortest-Paths ( L, W) 3. Extend-Shortest-Paths ( L,W ) 1. Let B be a new n x n matrix for i ← 1 to n 2. do for k ← 1 to n 3. do B [ i,k ] ← min { L ( i , j ) + w ( v j , v k ) } 4. 1≤ j ≤ n 5. return B 12

TU/e Algorithms (2IL15) – Lecture 6 All-Pairs Shortest Paths: relation to matrix multiplication Recursive formula: L ( i,k,m ) = w ( v j , v k ) if m = 1 min { L ( i , j , m −1) + w ( v j , v k ) } if 1 < m ≤ n −1 1≤ j ≤ n A = matrix with a i,k = L [ i,k,m −1 ] = min length of path with m− 1 edges from v i to v k W = matrix such that w i,k = w ( v i , v k ) = weight of edge w ( v i , v k ) B = matrix with b i,k = L [ i,k,m ] = min length of path with m edges from v i to v k w 1,k b i,k = min ( a i,k + w i,k ) … a i,1 … a i,n = b i,k 1≤ j ≤ n w n,k replacing “min” by “∑” and “+” by “∙” gives normal matrix multiplication 13

TU/e Algorithms (2IL15) – Lecture 6 Let’s change notation for the matrices: D (m) = matrix with d i,k = L [ i,k,m ] = min length of path with m edges from v i to v k W = matrix such that w i,k = w ( v i , v k ) = weight of edge w ( v i , v k ) Then D (m) = D (m-1) W = ( D (m-2) W ) W = D (1) W W … W is associative m−1 times = W m 14

TU/e Algorithms (2IL15) – Lecture 6 Conclusion  Solving the All-Pairs Shortest Paths Problem is equivalent to computing the matrix product W n-1 with the -multiplication operator.  Extend-Shortest-Paths ( L,W ) computes matrix “product” L W We can use this insight to speed up the algorithm: repeated squaring: W → W 2 = W W → W 4 = W 2 W 2 → …  Extend-Shortest-Paths  W m = W n-1 for all m ≥ n−1 if there are no negative-weight cycles 15

TU/e Algorithms (2IL15) – Lecture 6 New algorithm Faster-All-Pairs-Shortest-Paths ( W ) \\ W is matrix with edge weights 1. L ← W; n ← number of rows of W // n = | V | 2. m ← 1 3. while m < n -1 4. do // Invariant: L = W m 5. L ← Extend -Shortest-Paths ( L,L ) // L ← L L 6. m ← 2 m 7. return L running time = O ( n 3 ) x number of times line 5 is executed = O ( n 3 log n ) … still need to check for negative-weight cycles. 16

TU/e Algorithms (2IL15) – Lecture 6 shortest path from v i to v k with m edges shortest path from v i to v j with m−1 edges v j v k v i Theorem: The All-Pairs Shortest-Paths problem for a graph G=( V,E ) with (possibly negative) edge weights can be solved in O ( |V | 3 log |V | ) time. PS There is a different algorithm – the Floyd-Warshall algorithm – that is also based on dynamic programming, but that runs in O( |V | 3 ) time. shortest path from v i to v k only using v 1 to v m on the way blackboard shortest path from v i to v j only using v 1 to v m-1 v m v k v i shortest path from v j to v k only using v 1 to v m-1 17

TU/e Algorithms (2IL15) – Lecture 6 An alternative approach: Johnson’s algorithm Suppose we want to solve a certain graph problem  we have an algorithm ALG that only works for certain types of graphs  we want to develop an algorithm for another type of graph Possible approaches A. try to adapt ALG B. try to modify the input graph G into a different graph G such that i. ALG can be applied to G ii. we can easily compute the solution for G from the solution for G 18