Dijkstra's Algorithm
Sources:
S. Skiena. The Algorithm Design Manual.
S. Sedgewick. Algorithms in C++ (3rd Edition)
Problem
Two algorithms, depending on what information
we want
Recall: All pairs shortest path: Floyd's algorithm
Single source shortest path: Dijkstra's algorithm
Dijkstra's Algorithm
Dijkstra's algorithm solves related problem to
APSP (Floyd's algorithm): Single source
shortest path (SSSP)
Idea: For a single node, what is shortest path to any
other node?
More restricted question
Can answer somewhat more quickly
Dijkstra's algorithm: Greedy approach
Dijkstra's Algorithm
Basic idea: Divide vertices into three groups
Tree vertices: We know the shortest path to these
Fringe vertices: Adjacent to a tree vertex; we don't
know the shortest path to these yet
Distant vertices: Not adjacent to a tree vertex; we
don't consider them at all
Iterate n times:
Find fringe vertex with lowest distance from source
Move from fringe to tree
Update any vertices that are now fringe vertices
Example
Assume we start at A
3
D
F
7
4
H
8
3
E
4
J
9
Vertex
Vertex
A*
A*
BB
CC
DD
EE
FF
GG
HH
II
JJ
Dist
Dist
00
77
-33
-------
Neigh
Neigh
-AA
-AA
-------
C
3
5
Tree
Fringe
Distant
Example
Add closest
3
D
F
7
4
H
8
3
E
4
J
9
Vertex
Vertex
A*
A*
BB
CC
D*
D*
EE
FF
GG
HH
II
JJ
Dist
Dist
00
77
-33
44
-10
10
----
Neigh
Neigh
-AA
-AA
DD
-DD
----
C
3
5
Tree
Fringe
Distant
Example
Add closest
3
D
F
7
4
H
8
3
E
4
J
9
Vertex
Vertex
A*
A*
BB
CC
D*
D*
E*
E*
FF
GG
HH
II
JJ
Dist
Dist
00
77
-33
44
88
10
10
----
Neigh
Neigh
-AA
-AA
DD
EE
DD
----
C
3
5
Tree
Fringe
Distant
Example
Add closest
3
D
F
7
4
H
8
3
E
4
J
9
Vertex
Vertex
A*
A*
B*
B*
CC
D*
D*
E*
E*
FF
GG
HH
II
JJ
Dist
Dist
00
77
-33
44
88
10
10
----
Neigh
Neigh
-AA
-AA
DD
EE
DD
----
C
3
5
Tree
Fringe
Distant
Example
Add closest
3
D
F
7
4
H
8
3
E
4
J
9
Vertex
Vertex
A*
A*
B*
B*
CC
D*
D*
E*
E*
F*
F*
GG
HH
II
JJ
Dist
Dist
00
77
-33
44
88
99
--14
14
Neigh
Neigh
-AA
-AA
DD
EE
FF
--FF
C
3
5
Tree
Fringe
Distant
Example
Add closest
3
D
F
7
4
H
8
3
E
4
J
9
Vertex
Vertex
A*
A*
B*
B*
CC
D*
D*
E*
E*
F*
F*
G*
G*
HH
II
JJ
Dist
Dist
00
77
-33
44
88
99
--14
14
Neigh
Neigh
-AA
-AA
DD
EE
FF
--FF
C
3
5
Tree
Fringe
Distant
10
Example
Add closest
3
D
F
7
4
H
8
3
E
4
J
9
Vertex
Vertex
A*
A*
B*
B*
CC
D*
D*
E*
E*
F*
F*
G*
G*
HH
II
J*
J*
Dist
Dist
00
77
19
19
33
44
88
99
22
22
23
23
14
14
Neigh
Neigh
-AA
JJ
AA
DD
EE
FF
JJ
JJ
FF
C
3
5
Tree
Fringe
Distant
11
Example
Add closest
3
D
F
7
4
H
8
3
E
4
J
9
Vertex
Vertex
A*
A*
B*
B*
C*
C*
D*
D*
E*
E*
F*
F*
G*
G*
HH
II
J*
J*
Dist
Dist
00
77
19
19
33
44
88
99
22
22
23
23
14
14
Neigh
Neigh
-AA
JJ
AA
DD
EE
FF
JJ
JJ
FF
C
3
5
Tree
Fringe
Distant
12
Example
Add closest
3
D
F
7
4
H
8
3
E
4
J
9
Vertex
Vertex
A*
A*
B*
B*
C*
C*
D*
D*
E*
E*
F*
F*
G*
G*
H*
H*
II
J*
J*
Dist
Dist
00
77
19
19
33
44
88
99
22
22
23
23
14
14
Neigh
Neigh
-AA
JJ
AA
DD
EE
FF
JJ
JJ
FF
C
3
5
Tree
Fringe
Distant
13
Example
Add closest
3
D
F
7
4
H
8
3
E
4
J
9
Vertex
Vertex
A*
A*
B*
B*
C*
C*
D*
D*
E*
E*
F*
F*
G*
G*
H*
H*
I*I*
J*
J*
Dist
Dist
00
77
19
19
33
44
88
99
22
22
23
23
14
14
Neigh
Neigh
-AA
JJ
AA
DD
EE
FF
JJ
JJ
FF
C
3
5
Tree
Fringe
Distant
14
Implementation
Question: How to implement?
Solution: A priority queue, implemented with a
heap
Need to be able to find fringe vertices quickly
Also need to be able to find least valued fringe
vertex
Order = distance from source vertex
Need to specify graph structure...
15
Graph Structure
class Vertex
data
index
qindex
neighbors
integer
Used for SSSP
nearestw
Elements are (float,int) pairs
First = weight of edge, second = index of neighbor
nearestv
label or similar
integer: Index in G.vertices
integer: Index in priority queue
list
float
Used for SSSP
class Graph
vertices
list of Vertex objects
16
Example
Example for this small graph:
G: Graph object
data = A, index=0
neighbors = [(7,1),(3,3)]
data = C, index=2
neighbors=[ (1,3) ]
<D>: Vertex object
data = D, index=3
neighbors = [ ]
D
7
2
B
data = B, index=1
neighbors=[ (2,0) ,(4,3) ]
<C>: Vertex object
<B>: Vertex object
vertices = [ <A>, <B>, <C>, <D> ]
<A>: Vertex object
1
4
C
17
Dijkstra's Algorithm
def dijkstra(G,src):
#G = graph
Q=[ ]
for v in G.vertices:
v.nearestv = None
if v.name == src:
v.nearestw=0
else:
v.nearestw=None
Q.append(tmp)
heapify(Q)
#None counts as infinity
for i in range(len(Q)):
Q[i].qindex = i
...continued...
18
Dijkstra's Algorithm
while len(Q) > 0:
x=heappop(Q) #updates qindex
for nn in x.neighbors:
ew = nn[0]
#edge weight
ni = nn[1]
#neighbor index
n = G.vertices[ ni ]
#neighbor itself
if n.nearestw == None or
n.nearestw > x.nearestw + ew:
n.nearestv = x.index
n.nearestw = x.nearestw + ew
reheapify(Q,n)
19
Reheapify
Remember, priority queue is sorted based on
distance from source vertex
If we change a vertex's nearest neighbor, we
might move it up in the queue
So this is what reheapify does
Parameters: The queue (array) and the index
node we have altered
20
Reheapify
def reheapify(Q,v):
vi = v.qindex
#index in queue
pi = (vi-1)/2
#parent's index in queue
p = Q[pi]
#parent node itself
while vi > 0 and p.nearestw > v.nearestw:
#swap queue entries for parent & v
tmp = Q[pi]
Q[pi] = Q[vi]
Q[vi] = tmp
#update qslot data
Q[pi].qslot = pi
Q[vi].qslot = vi
vi = pi
pi = (vi-1)/2
21
heappop
def heappop(Q):
x = Q[0]; y = Q.pop(); Q[0]=y; Q[0].qindex=0
vi = 0; li = vi*2+1 ; ri = vi*2+2
#li,ri=left/right children
while 1:
if li < len(Q): v1=Q[li].nearestw
else: v1 = infinity
if ri < len(Q): v2=Q[ri].nearestw
else: v2 = infinity
if v1 < Q[vi].value and v1<=v2:
tmp = Q[li]; Q[li]=Q[vi]; Q[vi]=tmp
Q[li].qindex = li; Q[vi].qindex=vi
vi=li
elif v2 < Q[vi].value and v2 <= v1:
...swap items vi and ri, move down to ri
else:
break
22
Analysis
How much time for Dijkstra?
Does V loop iterations
Each loop iteration takes time lg(V) (to pop and
reheapify)
Thus, O(V lg V) for vertex processing
Also, within loop, we consider all neighbors of
popped vertex
Each edge gets considered exactly once
So O(V lg V + E) time total
Dense graph: EV2
Thus, O(V2 + V lg V)
23
