- 69 Views
- Uploaded on
- Presentation posted in: General

All-pairs Shortest Paths

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

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) + 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

}

- 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

- Structure of a shortest path:

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

- G*=(V, E*), E*={ (i, j): there is a path from i to j in G}

- 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