All-pairs Shortest Paths
This presentation is the property of its rightful owner.
Sponsored Links
1 / 18

All-pairs Shortest Paths PowerPoint PPT Presentation


  • 66 Views
  • Uploaded on
  • Presentation posted in: General

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

Download Presentation

All-pairs Shortest Paths

An Image/Link below is provided (as is) to download presentation

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

Presentation Transcript


All pairs shortest paths

All-pairs Shortest Paths


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’


All pairs shortest paths

  • 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

  • All-pairs Shortest Paths:

    Input : G = (V,E), |V|= n

    W = (wij),

    Output : nn 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


All pairs shortest paths

  • 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


  • All pairs shortest paths

    • Extend-Shortest-Paths(D,W)

      { n  rows[D]

      Let D’ = (dij’) be an nn 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)


    All pairs shortest paths

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


    All pairs shortest paths

    • 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 pairs shortest paths

    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}


    All pairs shortest paths

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


    All pairs shortest paths

    • 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}


    All pairs shortest paths

    • 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


    All pairs shortest paths

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

      }


    All pairs shortest paths

    • 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


    All pairs shortest paths

    • 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:


    All pairs shortest paths

     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: 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


    All pairs shortest paths

    • 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


    All pairs shortest paths

    • 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(V2logV+VE) Fibonacci heap

    O(VElogV) binary heap


  • Login