Dijkstras Algorithm and the Bellman-Ford Algorithm Tyler Moore CSE - - PDF document

Dijkstra’s Algorithm and the Bellman-Ford Algorithm

Tyler Moore

CSE 3353, SMU, Dallas, TX

April 23, 2013

The many cases of finding shortest paths

We’ve already seen how to calculate the shortest path in an unweighted graph (BFS traversal) We’ll now study how to compute the shortest path in different circumstances for weighted graphs

1

Single-source shortest path on a weighted DAG (review from last week)

2

Single-source shortest path on a weighted graph with nonnegative weights (Dijkstra’s algorithm)

3

Single-source shortest path on a weighted graph including negative weights (Bellman-Ford algorithm)

4

All-pairs shortest path on a weighted graph with nonnegative weights Floyd-Warshall algorithm)

2 / 15

Shortest paths in DAGs

Key idea to dynamic programming: approach solutions as a sequential decision problem Each decision leads to new choices, and DP finds the best sequence

• f choices available

Like greedy algorithms but less myopic Recursive approach to finding the shortest path from a to z

1

Assume we already know the distance d(v) to z for each of a’s neighbors v ∈ G[a]

2

Select the neighbor v that minimizes d(v) + W (a, v)

3 / 15

Recursive solution to finding shortest path in DAGs

def r e c d a g s p (W, s , t ) : #Shortest path from s to t @memo #Memoize f def d(u ) : #Distance from u to t i f u == t : return 0# We ’ re there ! # Return the best

• f

every f i r s t step return min (W[ u ] [ v]+d( v ) for v in W[ u ] ) return d( s ) #Apply f to a c t u a l s t a r t node

4 / 15

Notes Notes Notes Notes

Shortest paths in DAGs: Iterative approach

The iterative solution is a bit more complicated

1

We must start with a topological sort

2

Keep track of an upper bound on the distance from a to each node, initialized to ∞

3

Go through each vertex and relax the distance estimate by inspecting the path from the vertex to its neighbor

In general, relaxing an edge (u, v) consists of testing whether we can shorten the path to v found so far by going through u; if we can, we update d[v] with the new value Running time: Θ(m + n)

5 / 15

Relaxing edges

s v u

1: d[v] = 13 2: W[u][v] = 3 2 : d [ u ] = 7

6 / 15

Relaxing edges

s v u

2: W[u][v] = 3 2 : d [ u ] = 7 3: d[v] = 13 10 i n f = f l o a t ( ’ i n f ’ ) def r e l a x (W, u , v , D, P ) : d = D. get (u , i n f ) + W[ u ] [ v ]# P o s s i b l e s h o r t c u t estimate i f d < D. get ( v , i n f ) : # I s i t r e a l l y a s h o r t c u t ? D[ v ] , P[ v ] = d , u # Update estimate and parent return True # There was a change !

6 / 15

Iterative solution to finding shortest path in DAGs

def dag sp (W, s , t ) : #Shortest path from s to t d = {u : f l o a t ( ’ i n f ’ ) for u in W} # Distance e s t i m a t e s d [ s ] = 0 #S t a r t node : Zero d i s t a n c e for u in t o p s o r t (W) : #In top−s o r t e d

• rder . . .

i f u == t : break #Have we a r r i v e d ? for v in W[ u ] : #For each out−edge . . . d [ v ] = min (d [ v ] , d [ u ] + W[ u ] [ v ] ) # Relax the edge return d [ t ] #Distance to t ( from s )

7 / 15

Notes Notes Notes Notes

But what if there are cycles?

With a DAG, we can select the order in which to visit nodes based on the topological sort With cycles we can’t easily determine the best order If there are no negative edges, we can traverse from the starting vertex, visiting nodes in order of their estimated distance from the starting vertex In Dijkstra’s algorithm, we use a priority queue based on minimum estimated distance from the source to select which vertices to visit Running time: Θ((m + n) lg n) Dijkstra’s algorithm combines approaches seen in other algorithms

1

Node discovery: bit like breadth-first traversal

2

Node visitation: selected using priority queue like Prim’s algorithm

3

Shortest path calculation: uses relaxation as in algorithm for shortest paths in DAGs

8 / 15

Dijkstra’s algorithm

from heapq import heappush , heappop def d i j k s t r a (G, s ) : D, P, Q, S = { s :0} , {} , [ ( 0 , s ) ] , s e t () # Est . , tree , queue , v i s i t e d while Q: # S t i l l unprocessed nodes ? , u = heappop (Q) # Node with lowest estimate i f u in S : continue # Already v i s i t e d ? Skip i t S . add (u) # We ’ ve v i s i t e d i t now for v in G[ u ] : # Go through a l l i t s neighbors r e l a x (G, u , v , D, P) # Relax the

• ut−edge

heappush (Q, (D[ v ] , v ))# Add to queue , w/ e s t . as p r i return D, P # F i n a l D and P returned

9 / 15

Dijkstra’s algorithm example

a b c e d

1 5 1 2 9 2 3 4 6 7

d[Node]: upper bd. dist. from a Node init. 1 (u=a) 2 (u=c) 3 (u=e) 4 (u=b) 5 (u=d) a b ∞ 10 8 8 8 8 c ∞ 5 5 5 5 5 d ∞ ∞ 14 13 9 9 e ∞ ∞ 7 7 7 7

10 / 15

But what if there are negative edges?

With negative edges, we can’t select the next vertex to visit cleverly Instead, we just relax all m edges n times in a row If, after n rounds, the upper bounds don’t shrink, then we’ve found the shortest path from the source But if the upper bounds still shrink after n rounds, then there is a negative cycle in the graph, which is a problem (why?) Running time: Θ(m · n)

11 / 15

Notes Notes Notes Notes

Bellman-Ford Algorithm

def b el l ma n f or d (G, s ) : D, P = { s :0} , {} # Zero−d i s t to s ; no parents for rnd in G: # n = l e n (G) rounds changed = False # No changes in round so f a r for u in G: # For every from−node . . . for v in G[ u ] : # . . . and i t s to−nodes . . . i f r e l a x (G, u , v , D, P ) : # Shortcut to v from u? changed = True # Yes ! So something changed i f not changed : break # No change in round : Done else : # Not done be f or e round n? r a i s e ValueError ( ’ n e ga t i v e c y c l e ’ ) # Negative c y c l e detected return D, P # Otherwise : D and P c o r r e c t

12 / 15

Bellman-Ford algorithm example

s t y z x

6 7 8 9 7 − 4 − 3 5 −2 2

d[Node]: upper bd. dist. from s Node init. 1 2 3 4 s t ∞ 6 6 2 2 x ∞ ∞ 114 4 4 y ∞ 7 7 7 7 z ∞ ∞ 2 2

• 2

Edge Eval. Order (t,x) (t,y) (t,z) (x,t) (y,x) (y,z) (z,x) (z,s) (s,t) (s,y)

13 / 15

From single-source to all-pairs shortest paths

The algorithms discussed so far calculated the shortest path to all vertices from a single source We might instead be interested in the shortest path to all vertices from all sources We could run Dijkstra’s or Bellman-Ford n times, one for each source But more efficient solutions exist, particularly when graphs are dense

14 / 15

All-pairs shortest path application

Let’s compare distances between airport hubs City New York Los Angeles Seattle Atlanta Dallas New York 2470 2400 760 1390 LA 2470 1940 1230 Seattle 2400 1908 2180 1660 Atlanta 760 1940 2180 729 Dallas 1390 1230 1660 729 Total 7020 7548 8148 5609 5009 The farness of a node in a connected graph is the sum of all shortest path distances to other nodes Closeness centrality: inverse of the average length of all shortest paths from a vertex

15 / 15

Notes Notes Notes Notes