# Chapter 25: All-Pairs Shortest-Paths

## Presentation on theme: "Chapter 25: All-Pairs Shortest-Paths"— Presentation transcript:

Chapter 25: All-Pairs Shortest-Paths

Some Algorithms When no negative edges
Using Dijkstra’s algorithm: O(V3) Using Binary heap implementation: O(VE lg V) Using Fibonacci heap: O(VE + V2log V) When no negative cycles Floyd-Warshall [1962]: O(V3) time When negative cycles Using Bellman-Ford algorithm: O(V2 E) = O(V4 ) Johnson [1977]: O(VE + V2log V) time based on a clever combination of Bellman-Ford and Dijkstra

Notations G = (V, E) with w: E -> R Input form: matrix W= (wij )
wij =0 if i = j , wij = the weight of the directed edge if i≠j and (i, j) є E, Otherwise wij = ∞ Output: D = (dij), dij = δ(i,j) the shortest weight path from i to j

A dynamic programming approach
1. characterize the structure of an optimal solution, 2. recursively define the value of an optimal solution, 3. compute the value of an optimal solution in a bottom-up fashion.

The structure of an optimal solution
Consider a shortest path p from vertex i to vertex j, and suppose that p contains at most m edges. Assume that there are no negative-weight cycles. Hence m ≤ n-1 is finite.

The structure of an optimal solution
If i = j, then p has weight 0 and no edge. If i≠j, we decompose p into i ~ k -> j where p’ contains at most m-1 edges. Moreover, p’ is a shortest path from i to k and δ(i,j) = δ(i,k) + wkj

Recursive solution to the all-pairs shortest-path problem
Define: lij(m) = minimum weight of any path from i to j that contains at most m edges. 0 if i = j lij(0) = ∞ if i ≠ j Then lij(m) = min{ lij(m-1), min1≤k≤n {lik(m-1) + wkj}} = min1≤k≤n {lik(m-1) + wkj} (why?)

Recursive solution to the all-pairs shortest-path problem
Since shortest path from i to j contains at most n-1 edges, δ(i,j) = lij(n-1) = lij(n) = lij(n+1) = … Computing the shortest-path weight bottom up: Compute L(1) ,L(2) ,…., L(n-1) where L(m)=(lij (m)) Note that L(1) = W.

EXTENDED-SHORTEST-PATHS(L, W)
Given matrices L(m-1) and W return L(m) n <- L.row Let L’ = (l’ij) be a new n x n matrix for i = 1 to n for j = 1 to n l’ij = ∞ for k = 1 to n l’ij = min(l’ij, lik + wkj) return L’

Example: W = 1 4 5 2 3 -4 7 6 -5 8

Matrix Multiplication
Let l(m-1) -> a w > b l(m) -> c min -> + + -> ‧ time complexity : O(n3) Cij = k=1 to n aik‧bkj lij(m) = min1≤k≤n {lik(m-1) + wkj}

SLOW-ALL-PAIRS-SHORTEST-PATHS(W)
L(1) = L(0) ‧ W = W L(2) = L(1) ‧ W = W2 L(3) = L(2) ‧ W = W3 L(n-1) = L(n-2) ‧W = Wn-1

SLOW-ALL-PAIRS-SHORTEST-PATHS(W)
1 n = W.rows 2 L(1) = W for m = 2 to n-1 let L(m) be a new n x n matrix L(m) = EXTENDED-SHORTEST PATHS( L(m-1), W ) return L(n-1) Time complexity : O(n4)

Improving the running time
L(1) = W L(2) = W2 =W．W L(4) =W4 = W2．W2 . i.e., using repeating squaring! Time complexity: O(n3lg n)

FASTER-ALL-PAIRS-SHORTEST-PATHS
FASTER-ALL-PAIRS-SHORTEST-PATHS(W) 1. n =W.row 2. L(1) =W 3. m =1 4. while m < n-1 let L(2m) be a new n x n matrix L(2m) = Extend-Shorest-Path(L(m), L(m)) m = 2m 8. return L(m)

The Floyd-Warshall algorithm
A different dynamic programming formulation ‧The structure of a shortest path: Let V(G)={1,2,…,n}. For any pair of vertices i, j єV, consider all paths from i to j whose intermediate vertices are drawn from {1, 2,…,k}, and let p be a minimum weight path among them.

The structure of a shortest path
If k is not in p, then all intermediate vertices are in {1, 2,…,k-1}. If k is an intermediate vertex of p, then p can be decomposed into i ~ k ~ j where p1 is a shortest path from i to k with all the intermediate vertices in {1,2,…,k-1} and p2 is a shortest path from k to j with all the intermediate vertices in {1,2,…,k-1}.

A recursive solution to the all-pairs shortest path
Let dijk =the weight of a shortest path from vertex i to vertex j with all intermediate vertices in the set {1,2,…,k}. dij(k) = wij if k = 0 = min(dij(k-1), dik(k-1) + dkj(k-1)) if k ≥ 1 D(n) = (dij(n)) if the final solution!

FLOYD-WARSHALL(W) 1. n = W.rows 2. D(0)= W 3. for k = 1 to n 4. Let D(k) = (dij(k)) be a new n x n matrix 5. for i = 1 to n 6. for j = 1 to n 7. dij(k) = min (dij(k-1), dik(k-1) + dkj(k-1)) 8. return D(n) Complexity: O(n3)

Constructing a shortest path
πij(k) : is the predecessor of the vertex j on a shortest path from vertex i with all intermediate vertices in the set {1,2,…,k}. πij(0) = NIL if i=j or wij = ∞ = i if i ≠j and wij < ∞ πij(k) = πij(k-1) if dij(k-1) ≤ dik(k-1) + dkj(k-1) = πkj(k-1) if dij(k-1) > dik(k-1) + dkj(k-1)

Example

Transitive closure of a directed graph
Given a directed graph G = (V, E) with V = {1,2,…, n} The transitive closure of G is G*= (V, E*) where E*={(i, j)| there is a path from i to j in G}. Modify FLOYD-WARSHALL algorithm: tij(0) = 0 if i≠j and (i,j) ∉ E 1 if i=j or (i,j) є E for k ≥ 1 tij(k) = tij(k-1) (tik(k-1) tkj(k-1))

TRANSITIVE-CLOSURE(G)
n = |G.V| Let T(0) = (tij(0)) be a new n x n matrix 3 for i = 1 to n for j =1 to n if i == j or (i, j) ∈ G.E tij(0) = 1 else tij(0) = 0 for k =1 to n Let T(k) = (tij(k)) be a new n x n matrix for i = 1 to n for j =1 to n tij(k) = tij(k-1) (tik(k-1)  tkj(k-1)) 123 return T(n) Time complexity: O(n3)

Example

Some Algorithms When no negative edges
Using Dijkstra’s algorithm: O(V3) Using Binary heap implementation: O(VE lg V) Using Fibonacci heap: O(VE + V2log V) When no negative cycles Floyd-Warshall [1962]: O(V3) time When negative cycles Using Bellman-Ford algorithm: O(V2 E) = O(V4 ) Johnson [1977]: O(VE + V2log V) time based on a clever combination of Bellman-Ford and Dijkstra

Johnson’s algorithm for sparse graphs
If all edge weights in G are nonnegative, we can find all shortest paths in O(V2lg V + VE) by using Dijkstra’s algorithm with Fibonacci heap Bellman-Ford algorithm takes O(VE) Using reweighting technique

Reweighting technique
If G has negative-weighted edge, we compute a new set of nonnegative weight that allows us to use the same method. The new set of edge weight ŵ satisfies: 1. 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 the weight function ŵ 2. ∀(u,v) є E(G), ŵ(u,v) is nonnegative

Lemma: (Reweighting doesn’t change shortest paths)
Given a weighted directed graph G = (V, E) with weight function w:E→R , let h:V →R be any function mapping vertices to real numbers. For each edge (u,v) є E, ŵ(u,v) = w(u,v) + h(u) – h(v) Let P=<v0,v1,…,vk> be a path from vertex v0 to vk Then w(p) = δ(v0,vk) if and only if ŵ(p) = (v0,vk) Also, G has a negative-weight cycle using weight function w iff G has a negative weight cycle using weight function ŵ.

Proof = (w(vi-1 ,vi) + h(vi-1)-h(vi)) = w(vi-1 ,vi) + h(v0)-h(vk)
ŵ(p) = w(p) + h(v0) – h(vk) ŵ(p) = ŵ(vi-1 ,vi) = (w(vi-1 ,vi) + h(vi-1)-h(vi)) = w(vi-1 ,vi) + h(v0)-h(vk) = w(p) + h(v0) – h(vk)

Proof Because h(v0) and h(vk) do not depend on the path, if one path from v0 to vk is shorter than another using weight function w, then it is also shorter using ŵ. Thus, w(p) = δ(v0,vk) if and only if ŵ(p) = (v0,vk)

Proof G has a negative-weight cycle using w iff G has a negative-weight cycle using ŵ.  Consider any cycle C=<v0,v1,…,vk> with v0=vk . Then ŵ(C) = w(C) + h(v0) – h(vk) = w(C) .

Producing nonnegative weight by reweighting
Given a weighted directed graph G = (V, E) We make a new graph G’= (V’,E’), V’ = V ∪ {s}, E’ = E ∪{(s,v): v є V} and w(s,v) = 0, for all v in V Let h(v) = δ(s, v) for all v V’ We have h(v) ≤ h(u) + w(u, v) (why?) ŵ(u, v) = w(u, v) + h(u) – h(v) ≥ 0

Example: -4 1 7 2 6 -5 8 3 4 5

-4 1 7 2 6 -5 8 3 4 -1 5 S

ŵ(u, v) = w(u, v) + h(u) – h(v)
h(v) = δ(s, v) ŵ(u, v) = w(u, v) + h(u) – h(v) 10 2 13 4 -1 -5 -4 3 5 1 S

JOHNSON algorithm 1 Computing G’, where G’.V = G.V ∪ {s} and G’.E= G.E ∪{(s, v): v є G.V} and w(s, v) = 0. 2 if BELLMAN-FORD(G’, w, s)= FALSE 3 print “the input graph contains negative weight cycle” 4 else for each vertex v є G’.V 5 set h(v) to be the value of δ(s, v) computed by the BF algorithm 6 for each edge (u, v) є G’.E, ŵ(u, v) = w(u, v) + h(u) – h(v)

JOHNSON algorithm 7 Let D = (duv) be a new n x n matrix
8 for each vertex u є G.V run DIJKSTRA (G, ŵ, u) to compute (u, v) for all v є V[G] . 10 for each vertex v є G.V duv = (u, v) + h(v) – h(u) 12 return D Complexity: O(V2lgV + VE)

10 2 13 4 3 5 1 2/1 2/-3 2/2 0/-4 0/0 10 2 13 4 3 5 1 0/0 2/3 0/-4 0/1 2/-1 10 2 13 4 3 5 1 0/0 0/4 2/7 2/3 0/5

10 2 13 4 3 5 1 2/2 0/-1 0/-5 0/0 2/-2 10 2 13 4 3 5 1 2/5 4/8 0/0 2/1 2/6

Homework Practice at home: Exercises: 25.1-5, 25.1-6, 25.1-7
Exercises: (Due: Jan. 4) Practice at home : Exercises: (Due: Jan. 4)

Quiz 5 Please show the ordering of the following vertices produced by Topological Sort Algorithm under-shorts pants belt shirt tie socks shoes jacket

Similar presentations