by Amber McKenzie

and Laura Boccanfuso

DIJKSTRAS ALGORITHM
Fibonacci Heap Implementation

Dijkstras Algorithm
Question: How do you know that Dijkstras
algorithm finds the shortest path and is
optimal when implemented with the
Fibonacci heap?

Single-Source Shortest Path

For a given vertex, determine the shortest
path between that vertex and every other
vertex, i.e. minimum spanning tree.

Premise of Dijkstras Algorithm

First, finds the shortest path from the vertex to

the nearest vertex.

Then, finds the shortest path to the next
nearest vertex, and so on.
These vertices, for which the shortest paths
have been found, form a subtree.
Thus, the next nearest vertex must be among
the vertices that are adjacent to those in the
subtree; these next nearest vertices are called
fringe vertices.

Premise cont.
The fringe vertices are maintained in a
priority queue which is updated with new
distances from the source vertex at every

iteration.
A vertex is removed from the priority queue
when it is the vertex with the shortest
distance from the source vertex of those
fringe vertices that are left.

Pseudocode
for every vertex v in V do
dv ; pv null
Insert(Q, v, dv) //initialize vertex priority in the priority queue
ds 0; Decrease(Q, s, ds) //update priority of s with ds
VT

for i 0 to |V| - 1 do
u* DeleteMin(Q) //delete the minimum priority element
VT Vt U {u*}
for every vertex u in V VT that is adjacent to u* do

if du* + w(u*, u) < du

du du* + w(u*, u); pu u*
Decrease(Q, u, du)

Dijkstras Algorithm
2

6
2

f
1
4

Dijkstras Algorithm
2

5
8

Tree vertices
a(-, 0)

Remaining vertices
b(a, 2) c(a, 5) d(a, 8) e(-, ) f(-, )

Dijkstras Algorithm
2

6
2

Tree vertices
b(a, 2)

Remaining vertices
c(b, 2+2) d(a, 8) e(-, ) f(b, 2+6)

Dijkstras Algorithm
2

6
2

f
1

Tree vertices
c(b, 4)

Remaining vertices
d(a, 8) e(c, 4+1) f(b, 8)

Dijkstras Algorithm
2

6
2

1
4

Tree vertices
e(c, 5)

Remaining vertices
d(a, 8) f(b, 8)

Dijkstras Algorithm
2

6
2

1
4

Tree vertices
d(a, 8)

Remaining vertices
f(b, 8)

Dijkstras Algorithm
a

b
6
2

f
1

Dijkstras Algorithm: Priority Queue

Tree vertices Remaining vertices
a(-, 0)
b(a, 2) c(a, 5) d(a, 8) e(-, ) f(-, )
b(a, 2)
c(b, 2+2) d(a, 8) e(-, ) f(b, 2+6)
c(b, 4)
d(a, 8) e(c, 4+1) f(b, 8)
e(c, 5)
d(a, 8) f(b, 8)
d(a, 8)
f(b, 8)
f(b, 8)

Fibonacci Heap Implementation

What makes the Fibonacci Heap optimally suited
for implementing the Dijkstra algorithm?

Manipulation of heap/queue
Time complexity efficiency

http://www.mcs.surrey.ac.uk/Personal/R.Knott/Fibonacci/fibnat.html#Rabbits

Fibonacci Heap Implementation

Manipulation of heap/queue
Insert operation: creates a new heap with one element then
performs a merge

Merge operation: concatenate the lists of

tree roots of the two heaps

Decrease_key: take the node, decrease the

5
9

key and reorder nodes if necessary, mark node

or cut (if smaller than parent)

Delete_min: take root of min element and remove; decrease

number of roots by linking together ones with same degree,
check each remaining node to find minimum and delete

Fibonacci Heap Implementation

Time Complexity Efficiency
Operation

USDL
List*

2-3 tree

Heap

Binomial

Fibonacci

make

O(1)

O(1)

O(1)

O(1)

O(1)

empty

O(1)

O(1)

O(1)

O(1)

O(1)

insert

O(1)

O(logn)

O(logn)

O(logn)

O(1)

find_min

O(n)

O(logn)

O(1)

O(logn)

O(1)

delete_min

O(n)

O(logn)

O(logn)

O(logn)

O(logn)

delete

O(1)

O(logn)

O(logn)

O(logn)

O(logn)

merge

O(1)

O(n)

O(n)

O(logn)

O(1)

decrease_key

O(1)

O(logn)

O(logn)

O(logn)

O(1)

* USDL list: Unsorted Doubly Linked list

Worst-case complexity
Formula to discover the worst-case complexity for

Dijkstras algorithm:
W(n,m) = O(n * cost of insert +

n * cost of delete_min +
m * cost of decrease_key)

(Where n = maximum size of priority queue

m = number of times inner loop is performed)

Worst-case complexity (cont.)

Unsorted linked list:
W(n,m) = O(n* 1 + n * n + m * 1) = O(n2)

2-3 Tree :
W(n,m) = O(n * logn + n * logn + m * logn) = O(mlogn)

Fibonacci Heap:
W(n,m) = O(n * 1 + n * logn + m * 1) = O(nlogn + m)

Optimality of Dijkstras Algorithm

Adversary argument
In this case, it is the argument that there exists a

path between the source vertex s and the target

vertex t that is shorter than the path already
determined by the algorithm.

Adversary Argument
Since we have already determined the shortest

paths to all the previous vertices that are now

in the tree, this must mean that the path from s
to t goes through some other vertex v whose
distance from s has yet to be determined
(meaning it is still in the priority queue).

Adversary Argument Cont.

The catch is that if this other vertex v
through which t passes is still in the priority
queue, then its distance to s is longer than

that of all other vertices already in the tree.

Thus it cannot be a shorter distance than
that which is already determined between s
and t.
s

References
Algorithms and Data Structures
Design, Correctness and Analysis
Jeffrey H. Kingston
A Result on the Computational Complexity of
Heuristic Estimates for the A* Algorithm
Marco Valtorta
The Design & Analysis of Algorithms
Anany Levitin

Animation
http://www.cs.auckland.ac.nz/software/AlgAnim/dijkstra.html#dijkstra_anim