Dijkstras Algorithm Fibonacci Heap

Implementation

- by Amber McKenzie
- and Laura Boccanfuso

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 ? 8 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) lt du
- du ? du w(u, u) pu ? u
- Decrease(Q, u, du)

Dijkstras Algorithm

Dijkstras Algorithm

2

b

a

5

c

8

f

d

e

Tree vertices Remaining vertices

a(-, 0)

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

Dijkstras Algorithm

2

b

a

5

6

2

c

8

f

d

e

Tree vertices Remaining vertices

b(a, 2)

c(b, 22) d(a, 8) e(-, 8 ) f(b, 26)

Dijkstras Algorithm

2

b

a

5

6

2

c

8

f

3

1

d

e

Tree vertices Remaining vertices

c(b, 4)

d(a, 8) e(c, 41) f(b, 8)

Dijkstras Algorithm

2

b

a

5

6

2

c

8

f

3

1

d

4

7

e

Tree vertices Remaining vertices

e(c, 5)

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

Dijkstras Algorithm

2

b

a

5

6

2

c

8

f

3

1

d

4

7

e

Tree vertices Remaining vertices

d(a, 8)

f(b, 8)

Dijkstras Algorithm

Dijkstras Algorithm Priority Queue

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

8) - b(a, 2) c(b, 22) d(a, 8) e(-, 8 ) f(b, 26)
- c(b, 4) d(a, 8) e(c, 41) 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/Fibon

acci/fibnat.htmlRabbits

Fibonacci Heap Implementation

- Manipulation of heap/queue
- Insert operation creates a new heap with one

element then performs a merge

4

2

- 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

7

5

9

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).

v

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.

v

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/A

lgAnim/dijkstra.htmldijkstra_anim