Shortest Path 5/15/2002 11:40 AM

Outline and Reading

Weighted graphs (§7.1)
Shortest Paths „ Shortest path problem
„ Shortest path properties
0 Dijkstra’s algorithm (§7.1.1)
8 A 4
2 „ Algorithm
8 2 3
B
7
C
1
D „ Edge relaxation
5 3 9 8 The Bellman-Ford algorithm (§7.1.2)
2 5
E F Shortest paths in dags (§7.1.3)
All-pairs shortest paths (§7.2.1)

Shortest Paths 1 Shortest Paths 2

Weighted Graphs Shortest Path Problem

Given a weighted graph and two vertices u and v, we want to
In a weighted graph, each edge has an associated numerical find a path of minimum total weight between u and v.
value, called the weight of the edge „ Length of a path is the sum of the weights of its edges.
Edge weights may represent, distances, costs, etc. Example:
Example: „ Shortest path between Providence and Honolulu
„ In a flight route graph, the weight of an edge represents the Applications
distance in miles between the endpoint airports
„ Internet packet routing
„ Flight reservations
849 PVD Driving directions
1843 ORD 2
„
849 PVD
SFO 14 1843 ORD 2
SFO 14
802

1205

43 LGA

802
17

1205
337

7 43 LGA
138 10 17
337

HNL 2555 99 7
LAX 1233
HNL 2555 138 10
99
DFW 1120 1233
LAX DFW 1120
MIA
MIA
Shortest Paths 3 Shortest Paths 4

Shortest Path Properties Dijkstra’s Algorithm

Property 1: The distance of a vertex We grow a “cloud” of vertices,
A subpath of a shortest path is itself a shortest path v from a vertex s is the beginning with s and eventually
Property 2: length of a shortest path covering all the vertices
There is a tree of shortest paths from a start vertex to all the other between s and v
vertices
We store with each vertex v a
Dijkstra’s algorithm label d(v) representing the
Example:
computes the distances distance of v from s in the
Tree of shortest paths from Providence
of all the vertices from a subgraph consisting of the cloud
849 PVD given start vertex s and its adjacent vertices
1843 ORD 2
SFO 14 Assumptions: At each step
802

the graph is connected We add to the cloud the vertex

1205

43 LGA „ „

17 u outside the cloud with the

337

7 the edges are

138 10 „

HNL 2555 99 undirected smallest distance label, d(u)

1233
LAX DFW 1120 „ the edge weights are „ We update the labels of the
vertices adjacent to u
MIA nonnegative

Shortest Paths 5 Shortest Paths 6

1
Shortest Path 5/15/2002 11:40 AM

Edge Relaxation Example

0 0
Consider an edge e = (u,z) 8 A 4 8 A 4
such that d(u) = 50 2 2
10 d(z) = 75 8 7 2 1 4 8 7 2 1 3
„ u is the vertex most recently e B C D B C D
added to the cloud u
s z
∞ 3 9 ∞ 5 3 9 8
„ z is not in the cloud
2 5 2 5
E F E F
The relaxation of edge e
updates distance d(z) as 0 0
follows: 8 A 4 8 A 4
d(u) = 50
d(z) ← min{d(z),d(u) + weight(e)} 10 d(z) = 60 2 2
u e 8 7 2 1 3 7 7 2 1 3
s z B C D B C D

5 3 9 11 5 3 9 8
2 5 2 5
E F E F
Shortest Paths 7 Shortest Paths 8

Example (cont.) Dijkstra’s Algorithm

0 A priority queue stores Algorithm DijkstraDistances(G, s)
A 4 the vertices outside the Q ← new heap-based priority queue
8
for all v ∈ G.vertices()
2 cloud
if v = s
7 7 2 1 3 „ Key: distance
B C D setDistance(v, 0)
„ Element: vertex else
5 3 9 8 Locator-based methods setDistance(v, ∞)
2 5 insert(k,e) returns a l ← Q.insert(getDistance(v), v)
E F „
locator setLocator(v,l)
0
replaceKey(l,k) changes while ¬Q.isEmpty()
8 A 4 „
the key of an item u ← Q.removeMin()
2 for all e ∈ G.incidentEdges(u)
7 2 3 We store two labels { relax edge e }
7 1
B C D with each vertex: z ← G.opposite(u,e)
3 9 „ Distance (d(v) label) r ← getDistance(u) + weight(e)
5 8
2 5 „ locator in priority if r < getDistance(z)
E F queue setDistance(z,r)
Q.replaceKey(getLocator(z),r)
Shortest Paths 9 Shortest Paths 10

Analysis Extension
Graph operations Using the template Algorithm DijkstraShortestPathsTree(G, s)
„ Method incidentEdges is called once for each vertex method pattern, we
Label operations can extend Dijkstra’s …
„ We set/get the distance and locator labels of vertex z O(deg(z)) times algorithm to return a
tree of shortest paths for all v ∈ G.vertices()
„ Setting/getting a label takes O(1) time …
from the start vertex
Priority queue operations setParent(v, ∅)
to all other vertices
„ Each vertex is inserted once into and removed once from the priority …
queue, where each insertion or removal takes O(log n) time We store with each
„ The key of a vertex in the priority queue is modified at most deg(w) vertex a third label: for all e ∈ G.incidentEdges(u)
times, where each key change takes O(log n) time „ parent edge in the { relax edge e }
shortest path tree z ← G.opposite(u,e)
Dijkstra’s algorithm runs in O((n + m) log n) time provided the
In the edge relaxation r ← getDistance(u) + weight(e)
graph is represented by the adjacency list structure
step, we update the if r < getDistance(z)
„ Recall that Σv deg(v) = 2m parent label setDistance(z,r)
The running time can also be expressed as O(m log n) since the setParent(z,e)
graph is connected Q.replaceKey(getLocator(z),r)

Shortest Paths 11 Shortest Paths 12

2
Shortest Path 5/15/2002 11:40 AM

Why Dijkstra’s Algorithm Why It Doesn’t Work for

Works
Dijkstra’s algorithm is based on the greedy
method. It adds vertices by increasing distance.
„ Suppose it didn’t find all shortest
distances. Let F be the first wrong
vertex the algorithm processed.
„ When the previous node, D, on the
true shortest path was considered, B C
its distance was correct.
But the edge (D,F) was relaxed at
„ 2
that time!
Negative-Weight Edges
Dijkstra’s algorithm is based on the greedy
method. It adds vertices by increasing distance.
0 0
8 A 4 8 A 4
2 „ If a node with a negative 6
7 7 2 1 3 incident edge were to be added 7 7 5 1 4
D B C D
late to the cloud, it could mess
3 9 up distances for vertices already 0 -8
5 8 5 9
5 in the cloud. 2 5
E F E F

„ Thus, so long as d(F)>d(D), F’s

distance cannot be wrong. That is, C’s true distance is 1, but
there is no wrong vertex. it is already in the cloud
with d(C)=5!
Shortest Paths 13 Shortest Paths 14

Bellman-Ford Algorithm Bellman-Ford Example

Works even with negative- Algorithm BellmanFord(G, s)
weight edges
Must assume directed
edges (for otherwise we
would have negative-
weight cycles)
Iteration i finds all shortest
paths that use i edges.
Running time: O(nm).
Can be extended to detect
a negative-weight cycle if it
exists
„ How?
Shortest Paths
Nodes are labeled with their d(v) values
for all v ∈ G.vertices() 8 0 4 8 0 4
if v = s -2 -2
setDistance(v, 0) 7 1 8 7 -2 1 4
else ∞ ∞ ∞ ∞ ∞ ∞
setDistance(v, ∞) 3 9 3 9
for i ← 1 to n-1 do -2 5 -2 5
for each e ∈ G.edges() ∞ ∞ ∞ ∞
{ relax edge e }
u ← G.origin(e)
z ← G.opposite(u,e) 8 0 4 8 0 4
r ← getDistance(u) + weight(e)
-2 -2
if r < getDistance(z)
setDistance(z,r) 5 8 7 1 -1 7 1
-2 4 5 -2 -1
1 3 9 3 9
-2 6 9 5 -2 4 5
∞ ∞ 1 9
15 Shortest Paths 16

DAG-based Algorithm DAG Example

Algorithm DagDistances(G, s)
Works even with
negative-weight edges
Uses topological order
Doesn’t use any fancy
data structures
Is much faster than
Dijkstra’s algorithm
Running time: O(n+m).
Shortest Paths
Nodes are labeled with their d(v) values
1 1
for all v ∈ G.vertices() 8 0 4 8 0 4
if v = s -2 -2
setDistance(v, 0) 4 8 -2 4 4
3 7 2 1 3 7 2 1
else ∞ ∞ ∞ ∞ ∞ ∞
setDistance(v, ∞) 3 9 3 9
Perform a topological sort of the vertices -5 5 -5 5
for u ← 1 to n do {in topological order} ∞ ∞ ∞ ∞
6 5 6 5
for each e ∈ G.outEdges(u)
{ relax edge e } 1 1
z ← G.opposite(u,e) 8 0 4 8 0 4
r ← getDistance(u) + weight(e)
-2 -2
if r < getDistance(z) 5 4 4
3 7 2 1 -1 3 7 2 1
setDistance(z,r) 8 -2 4 5 -2 -1
3 9 3 9
-5 1 7 5 -5 0 4 5
∞ ∞ 1 7
6 5 6 5
17 Shortest Paths (two steps) 18

3
Shortest Path
All-Pairs Shortest Paths
Find the distance
between every pair of
vertices in a weighted
directed graph G.
We can make n calls to
Dijkstra’s algorithm (if no
negative edges), which
takes O(nmlog n) time.
Likewise, n calls to
Bellman-Ford would take
O(n2m) time.
We can achieve O(n3)
time using dynamic
programming (similar to
the Floyd-Warshall
algorithm).
5/15/2002 11:40 AM
Algorithm AllPair(G) {assumes vertices 1,…,n}
for all vertex pairs (i,j)
if i = j
D0[i,i] ← 0
else if (i,j) is an edge in G
D0[i,j] ← weight of edge (i,j)
else
D0[i,j] ← + ∞
for k ← 1 to n do
for i ← 1 to n do
for j ← 1 to n do
Dk[i,j] ← min{Dk-1[i,j], Dk-1[i,k]+Dk-1[k,j]}
return Dn
i Uses only vertices numbered 1,…,k
(compute weight of this edge)
Uses only vertices
j
numbered 1,…,k-1 k Uses only vertices
numbered 1,…,k-1
Shortest Paths 19