All-pairs Shortest Paths

p2. The structure of a shortest path: All subpaths of a shortest path are shortest paths. p : a shortest path from vertex i to vertex j with at most m edges. Decompose p as : i  k  j p’ has at most m-1 edges.  (i, j) =  (i, k) + w kj A recursive sol. to the all-pairs shortest-paths problem : minimum weight of any path from vertex i to vertex j that contains at most m edges. P’

p3. Computing the shortest-path weights bottom up: W=(w ij ) = w ij Let D (m) = ( ) Given D (m-1) and W, return D (m)

p4. All-pairs Shortest Paths: Input : G = (V,E), |V|= n W = (w ij ), Output : n  n matrix D = (d ij ) d i,j : the weight of a shortest path from vertex i to vertex j d i,j =  (i, j) at termination (Let  (i, j) denote the shortest-path weight from vertex i to vertex j )  = (  ij ) : predecessor matrix No negative-weight cycle Adjacency-matrix i j  ij

p5. Print-All-Pairs-Shortest-Path( , i, j) { if i=j then print I else if  ij = NIL then print “no path from” i “to” j “exists” else Print-All-Pairs-Shortest-Path( , i,  ij ) print j } Dynamic Programming: Characterize the structure of an optimal sol. Recursively define the value of an optimal sol. Compute the value of an optimal sol in a bottom-up fashion

p6. Extend-Shortest-Paths(D,W) { n  rows[D] Let D’ = (d ij ’) be an n  n matrix for i=1 to n do for j=1 to n do d ij ’   for k=1 to n do d ij ’ = min (d ij ’, d ik + w kj ) return D’ } Slow-All-Pairs-Shortest-Paths(W) { n = rows[W] D (1) = W for m=2 to n-1 do D (m) = Extend-Shortest-Paths(D (m-1), W) return D (n-1) } Very similar to matrix-multiplication  (n 4 )

p7. Faster-All-Pairs-Shortest-Paths(W) {n = rows[W] D (1) = W m = 1 While n-1>m do D (2m) = Extend-Shortest-Paths(D (m), D (m) ) m = 2m return D (m) }  (n 3 logn) (Repeated squaring)

p8. Floyd-Warshall algorithm Structure of a shortest path: Intermediate vertex of a simple path p= is any vertex of p other than v 1 or v, that is, any vertex in the set {v 2, …, v -1 } Let V={1, …, n} and a subset {1, 2, …, k} for some k For any pair of vertices i, j  V, consider all paths from i to j whose intermediate vertices are all drawn from {1, 2, …, k} and let p be a minimum-weight path from among them

p9.  If k is not an intermediate vertex of path p, then all intermediate vertices of path p are in the set {1, 2, …, k-1}. Thus a shortest path from vertex i to vertex j with all intermediate vertices in the set {1, 2, …, k-1} is also a shortest path from i to j with all intermediate vertices in the set {1, 2, …, k}  all int. vertices in {1, 2, …, k-1} i k j p1p1 p2p2 p : all int. vertices in {1, 2, …, k} k : intermediate vertex of p

p10. A recursive solution to the all-pairs shortest-paths problem d ij (k) : the weight of a shortest path from i to j with all intermediate vertices in the set {1, 2, …, k} Computing the shortest-path weights bottom up Floyd-Warshall(W) {n = rows[W] D(0) = W for k=1 to n do for i=1 to n do for j=1 to n do return D (n) }  (n 3 )

p11. Constructing a shortest path:  ij (k) : the predecessor os vertex j on a shortest path from i with all intermediate vertices in the set {1, 2, …, k}

p12. Transitive closure of a directed graph G=(V,E): G*=(V, E*), E*={ (i, j): there is a path from i to j in G} For i, j, k = 1, 2, …, n, define t ij (k) =1, if  a path in G from i to j with all intermediate vertices in {1, 2, …, k}; otherwise t ij (k) =0

p13. TC(G) {n = | V[G] |; for i=1 to n do for j=1 to n do if i=j or (i, j)  E[G] then t ij (0) = 1 else t ij (0) = 0 for k=1 to n do for i=1 to n do for j=1 to n do return T (n) }

p14. Preserving shortest paths by reweighting:, which must satisfy 2 properties: For all pairs of vertices u, v  V, a shortest path from u to v using weight function w is also a shortest path from u to v using weight function For all edges (u, v), is non-negative

p15. Lemma: Given G=(V, E) weighted, directed graph with weight function w: E  R, let h: V  R be any function mapping vertices to real numbers. For each (u,v)  E, define Let p=  Then  Also G has a negative cycle with w iff G has a negative cycle with pf:

p16.  Suppose there is a shorter path p’ from v 0 to v k with Thus  Consider any cycle c=, where v 0 = v k Thus c has negative weight using w iff it has negative weight using Producing non-negative weights by reweighting: Given G=(V,E) with weight function w: E  R, make G’=(V’, E’), where V’=V  {s}, E’=E  {(s,v): v  V} Extend w s.t. w(s,v)=0 for all v  V Define h(v)=  (s,v) for all v  V’ For all edges (u,v)  E’, we have h(v)  h(u)+w(u,v) Thus

p17. Johnson’s algorithm for sparse graphs: Input : sparse graph in adj. list representation Output : either returns a matrix of shortest-path weights for all pairs or reports that the input graph contains a negative- weight cycle

p18. Johnson(G) {compute G’, where V[G’]=V[G]  {s} and E[G’]=E[G]  {(s,v):v  V[G]} if Bellman-Ford(G’, w, s)=False then print “  a negative-weight cycle” else for each vertex v  V[G’] do set h(v)=  (s,v) computed by the Bellman-Ford algo. for each edge (u,v)  E[G’] do for each vertex u  V[G] do run Dijkstra(G,, u) to compute for all v  V[G] for each v  V[G] do return D } O(V 2 logV+VE) Fibonacci heap O(VElogV) binary heap