Dijkstra'S Algorithm: Fibonacci Heap Implementation

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)

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

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

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

Dijkstra'S Algorithm: Fibonacci Heap Implementation

Uploaded by

Copyright:

Available Formats

Dijkstra'S Algorithm: Fibonacci Heap Implementation

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Dijkstra'S Algorithm: Fibonacci Heap Implementation

Uploaded by

Copyright:

Available Formats

by Amber McKenzie

and Laura Boccanfuso

Single-Source Shortest Path

Premise of Dijkstras Algorithm

the nearest vertex.

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

Dijkstras Algorithm: Priority Queue

Fibonacci Heap Implementation

Fibonacci Heap Implementation

Merge operation: concatenate the lists of

Decrease_key: take the node, decrease the

key and reorder nodes if necessary, mark node

Delete_min: take root of min element and remove; decrease

Fibonacci Heap Implementation

* USDL list: Unsorted Doubly Linked list

(Where n = maximum size of priority queue

Worst-case complexity (cont.)

Optimality of Dijkstras Algorithm

path between the source vertex s and the target

paths to all the previous vertices that are now

Adversary Argument Cont.

that of all other vertices already in the tree.

You might also like