23/4/18 chapter25 1
4.4 Single-Source Shortest Paths
• Problem Definition
• Shortest paths and Relaxation
• Dijkstra’s algorithm (can be viewed as a greedy algorithm)
23/4/18 chapter25 2
Problem Definition:• Real problem: A motorist wishes to find the shortest
possible route from Chicago to Boston.Given a road map of the United States on which the distance between each pair of adjacent intersections is marked, how can we determine this shortest route?
• Formal definition: Given a directed graph G=(V, E, W), where each edge has a weight, find a shortest path from s to v for some interesting vertices s and v.
• s—source
• v—destination.
23/4/18 chapter25 3
Find a shortest path from station A to station B.
-need serious thinking to get a correct algorithm.
A
B
23/4/18 chapter25 4
Shortest path:• The weight of path p=<v0,v1,…,vk > is the sum of
the weights of its constituent edges:
k
i
ii vvwpw1
1 ),()(
The cost of the shortest path from s to v is denoted as (s, v).
23/4/18 chapter25 5
Negative-Weight edges:• Edge weight may be negative. • negative-weight cycles– the total weight in the
cycle (circuit) is negative. • If no negative-weight cycles reachable from the
source s, then for all v V, the shortest-path weight remains well defined,even if it has a negative value.
• If there is a negative-weight cycle on some path from s to v, we define = - .
),( vs
),( vs
23/4/18 chapter25 6
Figure1 Negative edge weights in a directed graph.Shown within each vertex is itsshortest-path weight from source s.Because vertices e and f form a negative-weight cycle reachable from s,they have shortest-path weights of - . Because vertex g is reachable from a vertex whose shortest path is - ,it,too,has a shortest-path weightof - .Vertices such as h, i ,and j are not reachable from s,and so their shortest-pathweights are , even though they lie on a negative-weight cycle.
0 115
-13
h i
j
2
3-8
3
5
2
s
-4
4
8
7
a b
c d
e f
g
6
-3
3
-6
23/4/18 chapter25 7
Representing shortest paths:
• we maintain for each vertex vV , a predecessor
[ v] that is the vertex in the shortest path
right before v. • With the values of , a backtracking process can
give the shortest path. (We will discuss that after the algorithm is given)
23/4/18 chapter25 8
• Observation: (basic)• Suppose that a shortest path p from a source s to a
vertex v can be decomposed into
s u vfor some vertex u and path p’. Then, the
weight of a shortest path from s to v is
'p
),(),(),( vuwusvs We do not know what is u for v, but we know u is in V and we
can try all nodes in V in O(n) time.
Also, if u does not exist, the edge (s, v) is the shortest.
Question: how to find (s, u), the first shortest from s to some node?
23/4/18 chapter25 9
Relaxation:
• The process of relaxing an edge (u,v) consists of testing whether we can improve the shortest path to v found so far by going through u and,if so,updating d[v] and [v].
• RELAX(u,v,w)
• if d[v]>d[u]+w(u,v)
• then d[v] d[u]+w(u,v) (based on observation)
• [v] u
23/4/18 chapter25 10
Figure2 Relaxation of an edge (u,v).The shortest-path estimate of each vertex is shown within the vertex. (a)Because d[v]>d[u]+w(u,v) prior to relaxation,the value of d[v] decreases. (b)Here, d[v] d[u]+w(u,v) before the relaxation
step,so d[v] is unchanged by relaxation.
5 9
u v
5 7
u v
5 6
u v
5 6
u v
2 2
2 2
(a) (b)
RELAX(u,v) RELAX(u,v)
23/4/18 chapter25 11
Initialization:
• For each vertex v V, d[v] denotes an upper bound on the weight of a shortest path from source s to v.
• d[v]– will be (s, v) after the execution of the algorithm.
• initialize d[v] and [v] as follows: .
• INITIALIZE-SINGLE-SOURCE(G,s)
• for each vertex v V[G]
• do d[v]
• [v] NIL
• d[s] 0
23/4/18 chapter25 12
Dijkstra’s Algorithm:
• Dijkstra’s algorithm assumes that w(e)0 for each e in the graph.
• maintain a set S of vertices such that– Every vertex v S, d[v]=(s, v), i.e., the shortest-path from s to v
has been found. (Intial values: S=empty, d[s]=0 and d[v]=)
• (a) select the vertex uV-S such that
d[u]=min {d[x]|x V-S}. Set S=S{u}
(b) for each node v adjacent to u do RELAX(u, v, w).
• Repeat step (a) and (b) until S=V.
23/4/18 chapter25 13
Continue:
• DIJKSTRA(G,w,s):
• INITIALIZE-SINGLE-SOURCE(G,s)
• S
• Q V[G]
• while Q
• do u EXTRACT -MIN(Q)
• S S {u}
• for each vertex v Adj[u]
• do RELAX(u,v,w)
23/4/18 chapter25 14
Implementation:
• a priority queue Q stores vertices in V-S, keyed by their d[] values.
• the graph G is represented by adjacency lists.
23/4/18 chapter25 15
0
105
2
1
3 4
2
6
97
s
u v
x y8 8
8 8
(a)
23/4/18 chapter25 16
0
5/s
10/s
105
2
1
3 4
2
6
97
s
u v
x y8
8
(b)(s,x) is the shortest path using one edge. It is also the shortest path from s to x.
23/4/18 chapter25 17
0
7/x
14/x
5/s
8/x
105
2
1
3 4
2
6
97
s
u v
x y
(c)
23/4/18 chapter25 18
0
7/x
13/y
5/s
8/x
105
2
1
3 4
2
6
97
s
u v
x y
(d)
23/4/18 chapter25 19
0
7/x
9/u
5/s
8/x
105
2
1
3 4
2
6
97
s
u v
x y
(e)
23/4/18 chapter25 20
0
7/x
9/u
5/s
8/x
105
2
1
3 4
2
6
97
s
u v
x y
(f)Backtracking: v-u-x-s
23/4/18 chapter25 21
Theorem: Consider the set S at any time in the algorithm’s execution. For each vS, the path Pv is a shortest s-v path.
Proof: We prove it by induction on |S|.1. If |S|=1, then the theorem holds. (Because d[s]=0
and S={s}.)
2. Suppose that the theorem is true for |S|=k for some k>0.
3. Now, we grow S to size k+1 by adding the node v.
23/4/18 chapter25 22
Proof: (continue)Now, we grow S to size k+1 by adding the node v.
Let (u, v) be the last edge on our s-v path Pv, i.e., d[v]=d[u]+w(u, v).
Consider any other path from P: s,…,x,y, …, v. (red in the Fig.)
Case 1: y is the first node that is not in S and xS.
Since we always select the node with the smallest value d[] in the algorithm, we have d[v]d[y].
Moreover, the length of each edge is 0.
Thus, the length of Pd[y]d[v].
That is, the length of any path d[v].
s
xy
u vSet S
Case 2: such a y does not exist.
d[v]=d[u]+w(u, v)d[x]+w(x, v).
That is, the length of any path d[v].
23/4/18 chapter25 23
The algorithm does not work if there are negative weight edges in the graph
.
1
2-10
s v
u
S->v is shorter than s->u, but it is longer than
s->u->v.
23/4/18 chapter25 24
Time complexity of Dijkstra’s Algorithm:• Time complexity depends on implementation of the Queue.• Method 1: Use an array to story the Queue• EXTRACT -MIN(Q) --takes O(|V|) time.
– Totally, there are |V| EXTRACT -MIN(Q)’s. – time for |V| EXTRACT -MIN(Q)’s is O(|V|2).
• RELAX(u,v,w) --takes O(1) time. – Totally |E| RELAX(u, v, w)’s are required.– time for |E| RELAX(u,v,w)’s is O(|E|).
• Total time required is O(|V|2+|E|)=O(|V|2)• Backtracking with [] gives the shortest path in inverse
order.• Method 2: The priority queue is implemented as a
adaptable heap. It takes O(log n) time to do EXTRACT-MIN(Q) as well as | RELAX(u,v,w). The total running time is O(|E|log |V| ).
