Download
1 / 18
180 likes | 315 Views
All-pairs Shortest Paths. 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
E N D
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) + wkj • 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’
Computing the shortest-path weights bottom up: W=(wij) = wij Let D(m)= ( ) Given D(m-1) and W, return D(m)
All-pairs Shortest Paths: Input : G = (V,E), |V|= n W = (wij), Output : nn matrix D = (dij) di,j : the weight of a shortest path from vertex i to vertex j di,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 j i ij
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
Extend-Shortest-Paths(D,W) { n rows[D] Let D’ = (dij’) be an nn matrix for i=1 to n do for j=1 to n do dij’ for k=1 to n do dij’ = min (dij’ , dik + wkj) 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 (n4)
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) } (n3logn) (Repeated squaring)
Floyd-Warshall algorithm • Structure of a shortest path: Intermediate vertex of a simple path p=<v1 , …, v> is any vertex of p other than v1 or v, that is, any vertex in the set {v2 , …, 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
all int. vertices in {1, 2, …, k-1} all int. vertices in {1, 2, …, k-1} p1 p2 k i j p : all int. vertices in {1, 2, …, k} k : intermediate vertex of p 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}
A recursive solution to the all-pairs shortest-paths problem dij(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) } (n3)
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}
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 tij(k)=1, if a path in G from i to j with all intermediate vertices in {1, 2, …, k}; otherwise tij(k)=0
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 tij(0) = 1 else tij(0) = 0 for k=1 to n do for i=1 to n do for j=1 to n do return T(n) }
Preserving shortest paths by reweighting: , which must satisfy 2 properties: • For all pairs of vertices u, vV, 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
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=<v0, …, vk> Then Also G has a negative cycle with w iff G has a negative cycle with pf:
Suppose there is a shorter path p’ from v0 to vk with Thus Consider any cycle c=<v0, v1, …, vk> , where v0 = vk 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: ER , make G’=(V’, E’) , where V’=V{s} , E’=E{(s,v): vV} Extend w s.t. w(s,v)=0 for all vV Define h(v)=(s,v) for all vV’ For all edges (u,v)E’ , we have h(v) h(u)+w(u,v) Thus
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
Johnson(G) { compute G’, where V[G’]=V[G]{s} and E[G’]=E[G]{(s,v):vV[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(V2logV+VE) Fibonacci heap O(VElogV) binary heap
