DIJKSTRAS ALGORITHM Fibonacci Heap Implementation SingleSource Shortest Path

DIJKSTRA’S ALGORITHM Fibonacci Heap Implementation

Single-Source Shortest Path For a given vertex, determine the shortest path between that vertex and every other vertex, i. e. spanning tree with minimal path costs from the source vertex.

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* ← Delete. Min(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 2 a b 5 2 c 8 d 6 3 f 1 4 7 e

Dijkstra’s Algorithm 2 a b 5 8 c f d e Tree vertices a(-, 0) Remaining vertices b(a, 2) c(a, 5) d(a, 8) e(-, ∞) f(-, ∞)

Dijkstra’s Algorithm 2 a b 5 8 6 2 c f d e Tree vertices b(a, 2) Remaining vertices c(b, 2+2) d(a, 8) e(-, ∞ ) f(b, 2+6)

Dijkstra’s Algorithm 2 a b 5 2 c 8 d 6 3 f 1 e Tree vertices c(b, 4) Remaining vertices d(a, 8) e(c, 4+1) f(b, 8)

Dijkstra’s Algorithm 2 a b 5 3 e(c, 5) f 1 4 7 Tree vertices 2 c 8 d 6 e Remaining vertices d(a, 8) f(b, 8)

Dijkstra’s Algorithm 2 a b 5 2 c 8 d 3 d(a, 8) f 1 4 7 Tree vertices 6 e Remaining vertices f(b, 8)

Dijkstra’s Algorithm a 2 b 6 2 8 d c f 1 e

Dijkstra’s 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)

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 4 2 Ø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 7

Fibonacci Heap Implementation Time Complexity Efficiency Operation USDL List* 2 -3 tree Heap Binomial Fibonacci make O(1) O(1) empty O(1) O(1) insert O(1) O(logn) O(1) find_min O(n) O(logn) O(1) delete_min O(n) O(logn) delete O(1) O(logn) merge O(1) O(n) O(logn) O(1) decrease_key O(1) O(logn) O(1) * USDL list: Unsorted Doubly Linked list

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(n 2) Ø 2 -3 Tree : W(n, m) = O(n * logn + m * logn) = O(mlogn) Ø Fibonacci Heap: W(n, m) = O(n * 1 + n * logn + m * 1) = O(nlogn + m)