dijkstra’s algorithm fibonacci heap implementation
DESCRIPTION
by Amber McKenzie and Laura Boccanfuso. Dijkstra’s Algorithm Fibonacci Heap Implementation. Dijkstra’s Algorithm. Question : How do you know that Dijkstra’s algorithm finds the shortest path and is optimal when implemented with the Fibonacci heap?. Single-Source Shortest Path. - PowerPoint PPT PresentationTRANSCRIPT
by Amber McKenzieand Laura Boccanfuso
Dijkstra’s Algorithm
Question: How do you know that Dijkstra’s 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 Dijkstra’s 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)
Dijkstra’s Algorithm
a
d
c
b
f
e
2
3
7
5
8
2
1
6
4
Dijkstra’s Algorithm
a
d
c
b
f
e
2
5
8
a(-, 0)
Tree vertices Remaining verticesb(a, 2) c(a, 5) d(a, 8) e(-, ∞) f(-, ∞)
Dijkstra’s Algorithm
a
d
c
b
f
e
2
5
8
26
b(a, 2)
Tree vertices Remaining verticesc(b, 2+2) d(a, 8) e(-, ∞ ) f(b, 2+6)
Dijkstra’s Algorithm
a
d
c
b
f
e
2
3
5
8
2
1
6
c(b, 4)
Tree vertices Remaining verticesd(a, 8) e(c, 4+1) f(b, 8)
Dijkstra’s Algorithm
a
d
c
b
f
e
2
3
7
5
8
2
1
6
4
e(c, 5)
Tree vertices Remaining verticesd(a, 8) f(b, 8)
Dijkstra’s Algorithm
a
d
c
b
f
e
2
3
7
5
8
2
1
6
4
d(a, 8)
Tree vertices Remaining verticesf(b, 8)
Dijkstra’s Algorithm
a
d
c
b
f
e
2
8
2
1
6
Dijkstra’s Algorithm: Priority QueueTree 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
Manipulation of heap/queue
Time complexity efficiency
What makes the Fibonacci Heap optimally suited
for implementing the Dijkstra algorithm?
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
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
4
7
2
9
5
Fibonacci Heap Implementation
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
Time Complexity Efficiency
Worst-case complexity
Formula to discover the worst-case complexity for Dijkstra’s 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 Dijkstra’s 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.
s t
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).
s tv
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 tv
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