Single Source Shortest Path

(Dijkstras Algorithm)
 Shortest Path Problems
What is shortest path ?
shortest length between two vertices for an
unweighted graph:
smallest cost between two vertices for a weighted
graph:
B 210 B

A A
450
60 190

C unweighted C weighted
graph graph
200 130
D D
E E
 Shortest Path Problems
How can we find the shortest route between two
points on a map?
Model the problem as a graph problem:
Road map is a weighted graph:
vertices = cities
edges = road segments between cities
edge weights = road distances
Goal: find a shortest path between two vertices (cities)

3
 Shortest Path Problems
Input: t
6
x
3 9
Directed graph G = (V, E) 3
4
2 1
Weight function w : E R s 0
2 7
5 3
Weight of path p = v0, v1, . . . , vk 5 11
k 6
w( p ) w( vi 1 , vi ) y z
i 1

Shortest-path weight from u to v:

p
(u, v) = min w(p) : u v if there exists a path from u to v

otherwise

Shortest path u to v is any path p such that w(p) = (u, v)

4
 Variants of Shortest Paths
Single-source shortest path
G = (V, E) find a shortest path from a given source vertex s to
each vertex v V
Single-destination shortest path
Find a shortest path to a given destination vertex t from each
vertex v
Reverse the direction of each edge single-source
Single-pair shortest path
Find a shortest path from u to v for given vertices u and v
Solve the single-source problem
All-pairs shortest-paths
Find a shortest path from u to v for every pair of vertices u and v

5
Optimal Substructure of Shortest Paths
Given: vj
pjk
A weighted, directed graph G = (V, E) v1 pij
p1i
A weight function w: E R, pij vk
A shortest path p = v1, v2, . . . , vk from v1 to vk vi

A subpath of p: pij = vi, vi+1, . . . , vj, with 1 i j k

Then: pij is a shortest path from vi to vj

p1i pij pjk
Proof: p = v1 vi vj vk
w(p) = w(p1i) + w(pij) + w(pjk)
Assume pij from vi to vj with w(pij) < w(pij)
w(p) = w(p1i) + w(pij) + w(pjk) < w(p) contradiction!
6
 Shortest-Path Representation
For each vertex v V:
t x
d[v] = (s, v): a shortest-path estimate 3
6
9
Initially, d[v]= 3
4
2 1
Reduces as algorithms progress s 0
2 7
3
[v] = predecessor of v on a shortest
5
5 11
path from s
6
y z

If no predecessor, [v] = NIL

induces a treeshortest-path tree
Shortest paths & shortest path trees are
not unique
7
 Initialization
Alg.: INITIALIZE-SINGLE-SOURCE(V, s)
1. for each v V
2. do d[v]
3. [v] NIL
4. d[s] 0

All the shortest-paths algorithms start with

INITIALIZE-SINGLE-SOURCE

8
 Relaxation
Relaxing an edge (u, v) = testing whether we
can improve the shortest path to v found so far
by going through u
If d[v] > d[u] + w(u, v)
we can improve the shortest path to v
update d[v] and [v]
s s
u v u v
5
2
9
2 After relaxation:
5 6
d[v] d[u] + w(u, v)
RELAX(u, v, w) RELAX(u, v, w)

u v u v
2 2
5 7 5 6
9
 RELAX(u, v, w)
1. if d[v] > d[u] + w(u, v)
2. then d[v] d[u] + w(u, v)
3. [v] u

All the single-source shortest-paths algorithms

start by calling INIT-SINGLE-SOURCE
then relax edges
The algorithms differ in the order and how
many times they relax each edge

10
 Dijkstras Algorithm
Single-source shortest path problem:
No negative-weight edges: w(u, v) > 0 (u, v) E

Maintains two sets of vertices:

S = vertices whose final shortest-path weights have
already been determined
Q = vertices in V S: min-priority queue
Keys in Q are estimates of shortest-path weights (d[v])

Repeatedly select a vertex u V S, with the

minimum shortest-path estimate d[v]
11
 Dijkstra (G, w, s)
t x
1. INITIALIZE-SINGLE-SOURCE(V, s)
1

10 9
2. S 2 3 4 6
s 0
3. Q V[G] 5 7

4. while Q y
2
z

do u EXTRACT-MIN(Q)
t x
5.
10
1

6. S S {u} 10
2
9
4
s 0 3 6
7. for each vertex v Adj[u] 5 7

8. do RELAX(u, v, w)
5 2

y z

12
 Example
t 1 x t 1 x
8
10
14 8 13
14
10 9 10 9
2 3 4 6 2 3 4 6
s 0 s 0
5 7 5 7
5
7 5 7
2 2
y z y z

t x t 1 x
1
8 13
9 8 9
10 9 10 9

2 4 2 3 4 6
s 0 3 6 s 0

7 5 7
5
5 7 5 7
2 2
y z y z
13
 Dijkstra's Shortest Path Algorithm
Find shortest path from s to t.

24
2 3
9

s
18
14
2 6
6
30 4 19
11
15 5
5
6
20 16

t
7 44

14
 Dijkstra's Shortest Path Algorithm
S={ }
PQ = { s, 2, 3, 4, 5, 6, 7, t }

24
2 3
0 9

s
18
14 2 6
6
30 11
4 19

15 5
5
6
20 16

t
7 44
distance
15 label
 Dijkstra's Shortest Path Algorithm
S={ }
PQ = { s, 2, 3, 4, 5, 6, 7, t }

delmin


24
2 3
0 9

s
18
14 2 6
6
30 11
4 19

15 5
5
6
20 16

t
7 44
distance
16 label
 Dijkstra's Shortest Path Algorithm
S={s}
PQ = { 2, 3, 4, 5, 6, 7, t }
decrease key

X 9
24
2 3
0 9

s
18
14
X 14
2 6
6
30 11
4 19

15 5
5
6
20 16

t
7 44
distance
17 label 15
X
 Dijkstra's Shortest Path Algorithm
S={s}
PQ = { 2, 3, 4, 5, 6, 7, t }

delmin


X 9
24
2 3
0 9

s
18
14
X 14
2 6
6
30 11
4 19

15 5
5
6
20 16

t
7 44
distance
18 label 15
X
 Dijkstra's Shortest Path Algorithm
S = { s, 2 }
PQ = { 3, 4, 5, 6, 7, t }

X 9
24
2 3
0 9

s
18
14
X 14
2 6
6
30 11
4 19

15 5
5
6
20 16

t
7 44

19 15
X
 Dijkstra's Shortest Path Algorithm
S = { s, 2 }
PQ = { 3, 4, 5, 6, 7, t }
decrease key

33
X

X 9
24
2 3
0 9

s
18
14
X 14
2 6
6
30 11
4 19

15 5
5
6
20 16

t
7 44

20 15
X
 Dijkstra's Shortest Path Algorithm
S = { s, 2 }
PQ = { 3, 4, 5, 6, 7, t }

33
X

X 9
24
2 3
0 9
delmin
s
18
14
X 14
2 6
6
30 11
4 19

15 5
5
6
20 16

t
7 44

21 15
X
 Dijkstra's Shortest Path Algorithm
S = { s, 2, 6 }
PQ = { 3, 4, 5, 7, t }

32
33
X X

X 9
24
2 3
0 9

s
18
14
X 14
2 6
6
44
30
X 11
4 19

15 5
5
6
20 16

t
7 44

22 15
X
 Dijkstra's Shortest Path Algorithm
S = { s, 2, 6, 7 }
PQ = { 3, 4, 5, t }

32
33
X X

X 9
24
2 3
0 9

s
18
14
X 14
2 6
6
44
30
X 11
4 19

15 5
5
6
20 16

t
7 44

23 15
X delmin
 Dijkstra's Shortest Path Algorithm
S = { s, 2, 6, 7 }
PQ = { 3, 4, 5, t }

32
33
X X

X 9
24
2 3
0 9

s
18
14
X 14
2 6
6
X 35
44
30
X 11
4 19

15 5
5
6
20 16

t
7 44

24 15
X
59 X
 Dijkstra's Shortest Path Algorithm
S = { s, 2, 6, 7 } delmin
PQ = { 3, 4, 5, t }

32
33
X X

X 9
24
2 3
0 9

s
18
14
X 14
2 6
6
X 35
44
30
X 11
4 19

15 5
5
6
20 16

t
7 44

25 15
X
59 X
 Dijkstra's Shortest Path Algorithm
S = { s, 2, 3, 6, 7 }
PQ = { 4, 5, t }

32
33
X X

X 9
24
2 3
0 9

s
18
14
X 14
2 6
6
X 35
44 X 34
30
X 11
4 19

15 5
5
6
20 16

t
7 44

26 15
X 51 59
X X
 Dijkstra's Shortest Path Algorithm
S = { s, 2, 3, 6, 7 }
PQ = { 4, 5, t }

32
33
X X

X 9
24
2 3
0 9

s
18
14
X 14
2 6
6
X 35
44 X 34
30
X 11
4 19

15 5
5
6
20 16
delmin

t
7 44

27 15
X 51 59
X X
 Dijkstra's Shortest Path Algorithm
S = { s, 2, 3, 5, 6, 7 }
PQ = { 4, t }

32
33
X X

X 9
24
2 3
0 9

s
18
14
X 14
2 6
6
45 X
X 35
44 X 34
30
X 11
4 19

15 5
5
6
20 16

t
7 44

28 15
X 50 51
X 59
X X
 Dijkstra's Shortest Path Algorithm
S = { s, 2, 3, 5, 6, 7 }
PQ = { 4, t }

32
33
X X

X 9
24
2 3
0 9

s
18
14
X 14
2 6
6
45 X
X 35
44 X 34
30
X 11
4 19

15 5 delmin
5
6
20 16

t
7 44

29 15
X 50 51
X 59
X X
 Dijkstra's Shortest Path Algorithm
S = { s, 2, 3, 4, 5, 6, 7 }
PQ = { t }

32
33
X X

X 9
24
2 3
0 9

s
18
14
X 14
2 6
6
45 X
X 35
44 X 34
30
X 11
4 19

15 5
5
6
20 16

t
7 44

30 15
X 50 51
X 59
X X
 Dijkstra's Shortest Path Algorithm
S = { s, 2, 3, 4, 5, 6, 7 }
PQ = { t }

32
33
X X

X 9
24
2 3
0 9

s
18
14
X 14
2 6
6
45 X
X 35
44 X 34
30
X 11
4 19

15 5
5
6
20 16

t
7 44

31 15
X
delmin 50 51
X 59
X X
 Dijkstra's Shortest Path Algorithm
S = { s, 2, 3, 4, 5, 6, 7, t }
PQ = { }

32
33
X X

X 9
24
2 3
0 9

s
18
14
X 14
2 6
6
45 X
X 35
44 X 34
30
X 11
4 19

15 5
5
6
20 16

t
7 44

32 15
X 50 51
X 59
X X
 Dijkstra's Shortest Path Algorithm
S = { s, 2, 3, 4, 5, 6, 7, t }
PQ = { }

32
33
X X

X 9
24
2 3
0 9

s
18
14
X 14
2 6
6
45 X
X 35
44 X 34
30
X 11
4 19

15 5
5
6
20 16

t
7 44

33 15
X 50 51
X 59
X X
 Dijkstras Pseudo Code
Graph G, weight function w, root s

relaxing
edges
 Dijkstra (G, w, s)
1. INITIALIZE-SINGLE-SOURCE(V, s) (V)
2. S
3. Q V[G] O(V) build min-heap
4. while Q Executed O(V) times
5. do u EXTRACT-MIN(Q) O(lgV)
6. S S {u}
7. for each vertex v Adj[u]
8. do RELAX(u, v, w) O(E) times; O(lgV)
Running time: O(VlgV + ElgV) = O(ElgV)
35
 Dijkstras Running Time

Extract-Min executed |V| time

Decrease-Key executed |E| time
Time = |V| TExtract-Min + |E| TDecrease-Key
T depends on different Q implementations

Q T(Extract T(Decrease- Total

-Min) Key)
array O(V) O(1) O(V 2)
binary heap O(lg V) O(lg V) O(E lg V)
Fibonacci heap O(lg V) O(1) (amort.) O(V lgV + E)
 Implementations

With min-priority queue, Dijkstra algorithm can be

implemented in time
O(( m n) lg n).
With Fibonacci heap, Dijkstra algorithm can be implemented
in time
O(m n lg n).
With Radix heap, Dijkstra algorithm can be implemented
in time
O(m n lg c).
 Applications of Dijkstra's Algorithm
- Traffic Information Systems are most prominent use
- Mapping (Map Quest, Google Maps)
- Routing Systems