all-pairs shortest paths. p2. the structure of a shortest path: all subpaths of a shortest path are...
TRANSCRIPT
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) + 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’
(m)ijd
(0)ij
0 if i jd
if i j
(m) (m 1) (m 1)ij ij ik kj1 k n
(m 1)ik kj jj1 k n
d min(d ,min{d w })
=min{d w }, w 0 for all j
p3.
Computing the shortest-path weights bottom up:W=(wij) = wij Let D(m)= ( )
Given D(m-1) and W, return D(m)
(1)ijd (m)
ijd
p4.
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
ij
0 if i=j
w the weight of (i,j) if (i,j) E
if (i,j) E
No negative-weight cycle
Adjacency-matrix
ij
NIL if either i=j or there is no path from i to j
some predecessor of j on a shortest path from i
ij
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’ = (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) = Wfor 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)
p7.
Faster-All-Pairs-Shortest-Paths(W){ n = rows[W]
D(1) = Wm = 1While n-1>m do D(2m) = Extend-Shortest-Paths(D(m), D(m)) m = 2mreturn D(m)
}
(n3logn)
(Repeated squaring)
p8.
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 kFor any pair of vertices i, j V, consider all paths from ito 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
p1 p2
all int. vertices in {1, 2, …, k-1}
p : all int. vertices in {1, 2, …, k}
k : intermediate vertex of p
p10.
A recursive solution to the all-pairs shortest-paths problemdij
(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 upFloyd-Warshall(W){ n = rows[W]
D(0) = Wfor k=1 to n do for i=1 to n do for j=1 to n do
return D(n) }
ij(k)ij (k 1) (k 1) (k 1)
ij ik kj
w if k=0d
min(d ,d d )
(k) (k 1) (k 1) (k 1)ij ij ik kjd min(d ,d d )
(n3)
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}
ij(0)ij
ij
NIL if i=j or w
i if i j and w
(k 1) (k 1) (k 1) (k 1)ij ij ik kj(k)
ij (k 1) (k 1) (k 1) (k 1)kj ij ik kj
if d d d
if d d d
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 tij
(k)=1, if a path in G from i to j with all intermediate vertices in {1, 2, …, k}; otherwise tij
(k)=0(0)ij
0 i j and (i, j) Et
1 i = j or (i, j) E
(k) (k 1) (k 1) (k 1)ij ij ik kjt t (t t )
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 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)
}
(k) (k 1) (k 1) (k 1)ij ij ik kjt t (t t )
p14.
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
ˆw w
w
w(u,v)
: shortest-path weights with w
ˆ ˆ: shortest-path weights with w
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, defineLet p=<v0, …, vk>
Then Also G has a negative cycle with w iff G has a negative
cycle with
pf:
w(u,v) w(u,v) h(u) h(v)
0 k 0 kˆˆw(p) (v ,v ) iff w(p) (v ,v )
w
k k
i 1 i i 1 i i 1 ii 1 i 1
k
i 1 i 0 ki 1
0 k
ˆw(p) w(v ,v ) (w(v ,v ) h(v ) h(v ))
= w(v ,v ) h(v ) h(v )
= w(p) h(v ) h(v )
p16.
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
w
ˆw(p') w(p)
0 k 0 kˆw(p') h(v ) h(v ) w(p') w(p) w(p) h(v ) h(v )
w(p') w(p) Similarly for the converse
0 kw(c) w(c) h(v ) h(v )
w(c)
w
w(u,v) w(u,v) h(u) h(v) 0
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):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
}
w(u,v) w(u,v) h(u) h(v)
w ˆ(u,v)
uvˆd (u,v) h(v) h(u)
O(V2logV+VE) Fibonacci heap
O(VElogV) binary heap