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