1. Priority Queues MakeQueue create new empty queue
Insert(Q,k,p) insert key k with priority p
Delete(Q,k) delete key k (given a pointer)
DeleteMin(Q) delete key with min priority
Meld(Q1,Q2) merge two sets
Empty(Q) returns if empty
Size(Q) returns #keys
FindMin(Q) returns key with min priority
Question: What implementations do you know (search tree, unordered list, binary heaps) – what will the time be for these?

2. Priority Queues – Ideal Times
MakeQueue, Meld, Insert, Empty, Size, FindMin: O(1) Delete, DeleteMin: O(log n)
Question: What implementations do you know (search tree, unordered list, binary heaps) – what will the time be for these?

3. Dijkstra’s Algorithm (Single source shortest path problem)
Algorithm Dijkstra(V, E, w, s)
Q := MakeQueue
dist[s] := 0
Insert(Q, s, 0)
for v V \ { s } do
dist[v] := +∞
Insert(Q, v, +∞)
while Q ≠ do
v := DeleteMin(Q)
foreach u : (v, u)  E do
if u  Q and dist[v]+w(v, u) < dist[u] then
dist[u] := dist[v]+w(v, u)
DecreaseKey(u, dist[u])
n x Insert + n x DeleteMin + m x DecreaseKey Binary heaps / Binomial queues : O((n + m)∙log n)

4. Dijkstra’s Algorithm O(m + n∙log n)
Priority Bounds
Binomial Queues
[Vuillemin 78]
Fibonacci
Heaps
[Fredman, Tarjan 84]
Run-Relaxed
[Driscoll, Gabow, Shrairman, Tarjan 88]
[Brodal 96]
[Brodal, Lagogiannis, Tarjan 12]
Insert 1
Meld -
Delete
log n
DeleteMin
DecreaseKey 
Dijkstra’s Algorithm O(m + n∙log n)
Amortized Worst-case
(and Minimum Spanning Tree O(m∙log* n))
Empty, FindMin, Size, MakeQueue – O(1) worst-case time

5. Fibonacci Heaps: Structure
Set of heap-ordered trees.
Maintain pointer to minimum element.
Set of marked nodes.
each parent < its children
roots
heap-ordered tree
set -> unordered 17 24 23 7 3 30 26 46 18 52 41
Heap H 35 39 44

6. Fibonacci Heaps: Structure
Set of heap-ordered trees.
Maintain pointer to minimum element.
Set of marked nodes.
find-min takes O(1) time
min
set -> unordered 17 24 23 7 3 30 26 46 18 52 41
Heap H 35 39 44

7. Fibonacci Heaps: Structure
Set of heap-ordered trees.
Maintain pointer to minimum element.
Set of marked nodes.
True if the node lost its child, otherwise it is false
Use to keep heaps flat
Useful in decrease key operation
min
set -> unordered 17 24 23 7 3 30 26 46 18 52 41
Heap H 35
marked 39 44

8. Fibonacci Heap vs. Binomial Heap
Fibonacci Heap is similar to Binomial Heap, but has a less rigid structure
the heap is consolidated after the delete-min method is called instead of actively consolidating after each insertion This is called a “lazy” heap”....
min

9. Fibonacci Heaps: Notations
Notations in this slide
n = number of nodes in heap.
rank(x) = number of children of node x.
rank(H) = max rank of any node in heap H.
trees(H) = number of trees in heap H.
marks(H) = number of marked nodes in heap H.
trees(H) = 5
marks(H) = 3
n = 14
rank = 3
min
recall: with binomial heap, at most one tree of rank 0, 1, 2, 3, 4, …
nodes only change mark in Decrease-Key Can basically ignore marks until then.
marks are used to ensure size of heap is exponential in rank 17 24 23 7 3 30 26 46 18 52 41
Heap H 35
marked 39 44

10. Insert

11. Fibonacci Heaps: Insert
Create a new singleton tree.
Add to root list; update min pointer (if necessary).
insert 21 21
min 17 24 23 7 3 30 26 46 18 52 41
Heap H 35 39 44

12. Fibonacci Heaps: Insert
Create a new singleton tree.
Add to root list; update min pointer (if necessary).
insert 21
min
lazy insert - don't consolidate trees when inserting into Fibonacci heap. If k consecutive inserts, the k 1-node trees are created. 17 24 23 7 21 3 30 26 46 18 52 41
Heap H 35 39 44

13. Fibonacci Heaps: Insert Analysis
Actual cost. O(1)
min 17 24 23 7 21 3 30 26 46 18 52 41
Heap H 35 39 44

14. Linking Operation
extracting min is where the deferred work of consolidating the roots takes place

15. Linking Operation
Linking operation. Make larger root be a child of smaller root.
larger root
smaller root 15 3 56 24 18 52 41 77 39 44
tree T1
tree T2

16. Linking Operation
Linking operation. Make larger root be a child of smaller root.
15 is larger than 3
 Make ‘15’ be a child of ‘3’
larger root
smaller root 15 3 56 24 18 52 41 77 39 44
tree T1
tree T2

17. Linking Operation
Linking operation. Make larger root be a child of smaller root.
15 is larger than 3
 Make ‘15’ be a child of ‘3
larger root
smaller root
still heap-ordered 15 3 3 56 24 18 52 41 15 18 52 41 77 39 44 56 24 39 44
tree T1
tree T2 77
tree T'

18. Delete Min
extracting min is where the deferred work of consolidating the roots takes place

19. Fibonacci Heaps: Delete Min
Delete min; meld its children into root list; update min.
Consolidate trees so that no two roots have same rank.
min 7 24 23 17 3 30 26 46 18 52 41 35 39 44

20. Fibonacci Heaps: Delete Min
Delete min; meld its children into root list; update min.
Consolidate trees so that no two roots have same rank.
min 7 24 23 17 18 52 41 39 44 30 26 46 35

21. Fibonacci Heaps: Delete Min
Delete min; meld its children into root list; update min.
Consolidate trees so that no two roots have same rank.
min
current 7 24 23 17 18 18 52 41 39 44 30 26 46 35

22. Fibonacci Heaps: Delete Min
Delete min; meld its children into root list; update min.
Consolidate trees so that no two roots have same rank.
rank 1 2 3
min
current 7 24 23 17 18 52 41 39 44 30 26 46 35

23. Fibonacci Heaps: Delete Min
Delete min; meld its children into root list; update min.
Consolidate trees so that no two roots have same rank.
rank 1 2 3
min
current 7 24 23 17 18 18 52 41 39 44 30 26 46 35

24. Fibonacci Heaps: Delete Min
Delete min; meld its children into root list; update min.
Consolidate trees so that no two roots have same rank.
rank 1 2 3
min 7 24 23 17 18 18 52 41 39 44 30 26 46
current 35

25. Fibonacci Heaps: Delete Min
Delete min; meld its children into root list; update min.
Consolidate trees so that no two roots have same rank.
rank 1 2 3
min 7 24 23 17 18 18 52 41
current 39 44 30 26 46 35
link 23 into 17

26. Fibonacci Heaps: Delete Min
Delete min; meld its children into root list; update min.
Consolidate trees so that no two roots have same rank.
rank 1 2 3
min 7 24 17 18 18 52 41
current 23 39 44 30 26 46 35
link 17 into 7

27. Fibonacci Heaps: Delete Min
Delete min; meld its children into root list; update min.
Consolidate trees so that no two roots have same rank.
rank 1 2 3
current
min 24 7 18 18 52 41 17 30 39 44 26 46 35 23
link 24 into 7

28. Fibonacci Heaps: Delete Min
Delete min; meld its children into root list; update min.
Consolidate trees so that no two roots have same rank.
rank 1 2 3
current
min 7 18 18 52 41 24 17 30 39 44 26 46 23 35

29. Fibonacci Heaps: Delete Min
Delete min; meld its children into root list; update min.
Consolidate trees so that no two roots have same rank.
rank 1 2 3
current
min 7 18 18 52 41 24 17 30 39 44 26 46 23 35

30. Fibonacci Heaps: Delete Min
Delete min; meld its children into root list; update min.
Consolidate trees so that no two roots have same rank.
rank 1 2 3
current
min 7 18 18 52 41 24 17 30 39 44 26 46 23 35

31. Fibonacci Heaps: Delete Min
Delete min; meld its children into root list; update min.
Consolidate trees so that no two roots have same rank.
rank 1 2 3
current
min 7 18 18 52 41 24 17 30 39 44 26 46 23
link 41 into 18 35

32. Fibonacci Heaps: Delete Min
Delete min; meld its children into root list; update min.
Consolidate trees so that no two roots have same rank.
rank 1 2 3
current
min 7 52 18 18 24 17 30 41 39 26 46 23 44 35

33. Fibonacci Heaps: Delete Min
Delete min; meld its children into root list; update min.
Consolidate trees so that no two roots have same rank.
rank 1 2 3
current
min 7 52 18 18 24 17 30 41 39 26 46 23 44 35

34. Fibonacci Heaps: Delete Min
Delete min; meld its children into root list; update min.
Consolidate trees so that no two roots have same rank.
min 7 52 18 24 17 30 41 39 26 46 23 44
stop 35

35. Fibonacci Heaps: Delete Min Analysis
Actual cost. O(rank(H)) + O(trees(H))
O(rank(H)) to meld min's children into root list.
O(rank(H)) + O(trees(H)) to update min.
O(rank(H)) + O(trees(H)) to consolidate trees.
Amortized cost. O(rank(H))
O(rank(H)) work adding min's children since at most rank(H) children of min – максимальное количество потомков у минимального корня
O(rank(H) + trees(H)) work updating min since at most this many resulting root nodes – количество корней до + все новые корни - бывшие потомки минимума
O(rank(H) + trees(H)) to consolidate trees since number of roots decreases by 1 after each merging, and there at most rank(H) + trees(H) roots at beginning – слияние корней
trees(H') <= rank(H) + 1 since at worst the roots have degrees 0, 1, 2, …, rank(H)
can scale units in potential function to dominate cost hidden in O(trees(H))
number of marked nodes marked(H) does not increase [Note: you unmark a root y when it is linked to another root, though this case does not arise in the example]

36. Decrease Key

37. Fibonacci Heaps: Decrease Key
Intuition for deceasing the key of node x.
If heap-order is not violated, just decrease the key of x.
Otherwise, cut tree rooted at x and meld into root list.
To keep trees flat: as soon as a node has its second child cut, cut it off and meld into root list (and unmark it).
min 7 18 38
If decreasing the key of node i makes it violate heap order property, we can cutout subtree rooted at i and meld it into heap.
To keep trees bushy, we limit the number of cuts among the children of any vertex to 2.
Use the mark of a node to designate whether or not it has had one child cut off
marked node: one child already cut 24 17 23 21 39 41 26 46 30 52 35 88 72

38. Fibonacci Heaps: Decrease Key
Case 1. [heap order not violated]
Decrease key of x.
Change heap min pointer (if necessary).
min 7 18 18 38 24 17 23 21 39 41 26 46 29 30 52 x 35 88 72
decrease-key of x from 46 to 29

39. Fibonacci Heaps: Decrease Key
Case 1. [heap order not violated]
Decrease key of x.
Change heap min pointer (if necessary).
min 7 18 18 38 24 17 23 21 39 41 26 29 30 52 x 35 88 72
decrease-key of x from 46 to 29

40. Fibonacci Heaps: Decrease Key
Case 2a. [heap order violated]
Decrease key of x.
Cut tree rooted at x, meld into root list, and unmark.
If parent p of x is unmarked (hasn't yet lost a child), mark it; Otherwise, cut p, meld into root list, and unmark (and do so recursively for all ancestors that lose a second child).
min 7 18 18 38 24 17 23 21 39 41 p 26 29 15 30 52 x 35 88 72
decrease-key of x from 29 to 15

41. Fibonacci Heaps: Decrease Key
Case 2a. [heap order violated]
Decrease key of x.
Cut tree rooted at x, meld into root list, and unmark.
If parent p of x is unmarked (hasn't yet lost a child), mark it; Otherwise, cut p, meld into root list, and unmark (and do so recursively for all ancestors that lose a second child).
min 7 18 18 38 24 17 23 21 39 41 p 26 15 30 52 x 35 88 72
decrease-key of x from 29 to 15

42. Fibonacci Heaps: Decrease Key
Case 2a. [heap order violated]
Decrease key of x.
Cut tree rooted at x, meld into root list, and unmark.
If parent p of x is unmarked (hasn't yet lost a child), mark it; Otherwise, cut p, meld into root list, and unmark (and do so recursively for all ancestors that lose a second child). x
min 15 7 18 18 38 72 24 17 23 21 39 41 p 26 30 52 35 88
decrease-key of x from 29 to 15

43. Fibonacci Heaps: Decrease Key
Case 2a. [heap order violated]
Decrease key of x.
Cut tree rooted at x, meld into root list, and unmark.
If parent p of x is unmarked (hasn't yet lost a child), mark it; Otherwise, cut p, meld into root list, and unmark (and do so recursively for all ancestors that lose a second child). x
min 15 7 18 18 38 72 24 24 17 23 21 39 41 p
mark parent 26 30 52 35 88
decrease-key of x from 29 to 15

44. Fibonacci Heaps: Decrease Key
Case 2b. [heap order violated]
Decrease key of x.
Cut tree rooted at x, meld into root list, and unmark.
If parent p of x is unmarked (hasn't yet lost a child), mark it; Otherwise, cut p, meld into root list, and unmark (and do so recursively for all ancestors that lose a second child).
min 15 7 18 18 38 72 24 24 17 23 21 39 41 p 26 30 52 x 5 35 88
decrease-key of x from 35 to 5

45. Fibonacci Heaps: Decrease Key
Case 2b. [heap order violated]
Decrease key of x.
Cut tree rooted at x, meld into root list, and unmark.
If parent p of x is unmarked (hasn't yet lost a child), mark it; Otherwise, cut p, meld into root list, and unmark (and do so recursively for all ancestors that lose a second child).
min 15 7 18 18 38 72 24 24 17 23 21 39 41 p 26 30 52 x 5 88
decrease-key of x from 35 to 5

46. Fibonacci Heaps: Decrease Key
Case 2b. [heap order violated]
Decrease key of x.
Cut tree rooted at x, meld into root list, and unmark.
If parent p of x is unmarked (hasn't yet lost a child), mark it; Otherwise, cut p, meld into root list, and unmark (and do so recursively for all ancestors that lose a second child).
min x 15 5 7 18 18 38 72 24 24 17 23 21 39 41 p 26 30 52 88
decrease-key of x from 35 to 5

47. Fibonacci Heaps: Decrease Key
Case 2b. [heap order violated]
Decrease key of x.
Cut tree rooted at x, meld into root list, and unmark.
If parent p of x is unmarked (hasn't yet lost a child), mark it; Otherwise, cut p, meld into root list, and unmark (and do so recursively for all ancestors that lose a second child).
min x 15 5 7 18 18 38 72 24 24 17 23 21 39 41
second child cut p 26 30 52 88
decrease-key of x from 35 to 5

48. Fibonacci Heaps: Decrease Key
Case 2b. [heap order violated]
Decrease key of x.
Cut tree rooted at x, meld into root list, and unmark.
If parent p of x is unmarked (hasn't yet lost a child), mark it; Otherwise, cut p, meld into root list, and unmark (and do so recursively for all ancestors that lose a second child).
min x p 15 5 26 7 18 18 38 72 88 24 24 17 23 21 39 41 30 52
decrease-key of x from 35 to 5

49. Fibonacci Heaps: Decrease Key
Case 2b. [heap order violated]
Decrease key of x.
Cut tree rooted at x, meld into root list, and unmark.
If parent p of x is unmarked (hasn't yet lost a child), mark it; Otherwise, cut p, meld into root list, and unmark (and do so recursively for all ancestors that lose a second child).
min x p 15 5 26 7 18 18 38 72 88 p' 24 24 17 23 21 39 41 30 52
second child cut
decrease-key of x from 35 to 5

50. Fibonacci Heaps: Decrease Key
Case 2b. [heap order violated]
Decrease key of x.
Cut tree rooted at x, meld into root list, and unmark.
If parent p of x is unmarked (hasn't yet lost a child), mark it; Otherwise, cut p, meld into root list, and unmark (and do so recursively for all ancestors that lose a second child).
min x p p'
p'' 15 5 26 24 7 18 18 38
Note: when a root is linked into another root (in delete-min consolidation phase), we unmark it
Q. How can a root node ever be marked?
A. In delete-min we delete a root node, but promote all of its (potentially) marked children to be roots. 72 88
don't mark parent if it's a root 17 23 21 39 41 30 52
decrease-key of x from 35 to 5

51. Fibonacci Heaps: Decrease Key Analysis
Actual cost. O(c)
O(1) time for changing the key.
O(1) time for each of c cuts, plus melding into root list.
Amortized cost. O(1)
When marked node y is cut by cascading cut, its mark bit is cleared (2 units of potential).
One unit pays for cut, the other for unit increase in potential due to y becoming a root.
marks(H') <= marks(H) - c + 2: each cut (except first) unmarks a node; last cut may or may not mark a node
Can scale units of potential to dominate cost hidden in O(c) term

52. Analysis

53. Fibonacci Heaps: Bounding the Rank
Lemma. Fix a point in time. Let x be a node, and let y1, …, yk denote its children in the order in which they were linked to x. Then:
Def. Let Fk be smallest possible tree of rank k satisfying property. x y1 y2 … yk F0 F1 F2 F3 F4 F5
slightly non-standard definition of fibonacci with f0 = 1, f1 = 2 1 2 3 5 8 13

54. Fibonacci Heaps: Bounding the Rank
Lemma. Fix a point in time. Let x be a node, and let y1, …, yk denote its children in the order in which they were linked to x. Then:
Def. Let Fk be smallest possible tree of rank k satisfying property. x y1 y2 … yk F4 F5 F6
slightly non-standard definition of fibonacci with f0 = 1, f1 = 2 8 13
= 21

55. Fibonacci Heaps: Bounding the Rank
Lemma. Fix a point in time. Let x be a node, and let y1, …, yk denote its children in the order in which they were linked to x. Then:
Def. Let Fk be smallest possible tree of rank k satisfying property.
Fibonacci fact. Fk  k, where  = (1 + 5) / 2 
Corollary. rank(H)  log n . x y1 y2 … yk
golden ratio

56. Union

57. Fibonacci Heaps: Union
Union. Combine two Fibonacci heaps.
Representation. Root lists are circular, doubly linked lists.
min
min 23 24 17 7 3 21 30 26 46 18 52 41
Heap H' 35
Heap H'' 39 44

58. Fibonacci Heaps: Union
Union. Combine two Fibonacci heaps.
Representation. Root lists are circular, doubly linked lists.
min 23 24 17 7 3 21 30 26 46 18 52 41 35
Heap H 39 44

59. Fibonacci Heaps: Union
Actual cost. O(1)
Change in potential. 0
Amortized cost. O(1)
min 23 24 17 7 3 21 30 26 46 18 52 41 35
Heap H 39 44

60. Delete

61. Fibonacci Heaps: Delete
Delete node x.
decrease-key of x to -.
delete-min element in heap.
Amortized cost. O(rank(H))
O(1) amortized for decrease-key.
O(rank(H)) amortized for delete-min.

62. Persistent Data Structures

63. Motivation Version Control
Suppose we consistently modify a data structure
Each modification generates a new version of this structure
A persistent data structure supports queries of all the previous versions of itself
Three types of data structures
Fully persistent
all versions can be queried and modified
Partially persistent
all versions can be queried, only the latest version can be modified
Ephemeral
only can access the latest version

64. Making Data Structures Persistent
In the following, we will
Make pointer-based data structures persistent, e.g., tree
Discussions are limited to partial persistence
Three methods
Fat nodes
Path copying
Node Copying (Sleator, Tarjan et al.)

65. Fat Nodes value time1 time2 Add a modification history to each node
append the new data to the modification history, associated with timestamp
Access
for each node, search the modification history to locate the desired version
Complexity (Suppose m modifications)
value
time1
time2
Time
Space
Modification
O(1)
Access
O(log m) per node

66. Path Copying
Copy the node before changing it Cascade the change back until root is reached

67. Path Copying Copy the node before changing it
Cascade the change back until root is reached
version 0:
version 1:
Insert (2)
version 2:
Insert (4) 5 7 1 3

68. Path Copying Copy the node before changing it
Cascade the change back until root is reached
version 1:
Insert (2) 5 7 1 3 3 2

69. Path Copying Copy the node before changing it
Cascade the change back until root is reached
version 1:
Insert (2) 5 7 1 3 3 2

70. Path Copying Copy the node before changing it
Cascade the change back until root is reached 1
version 1:
Insert (2) 5 5 1 7 1 3 3 2

71. Path Copying Copy the node before changing it
Cascade the change back until root is reached 1 2
version 1:
Insert (2)
version 2:
Insert (4) 5 5 5 1 1 7 1 3 3 3 2 4

72. Path Copying Copy the node before changing it
Cascade the change back until root is reached
Each modification creates a new root
Maintain an array of roots indexed by timestamps 1 2
version 1:
Insert (2)
version 2:
Insert (4) 5 5 5 1 1 7 1 3 3 3 2 4

73. Path Copying Copy the node before changing it
Cascade the change back until root is reached
Modification
copy the node to be modified and its ancestors
Access
search for the correct root, then access as original structure
Complexity (Suppose m modifications, n nodes)
Time
Space
Modification
Worst: O(n)
Average: O(log n)
Access
O(log m)

74. Node Copying Fat nodes: cheap modification, expensive access
Path copying: cheap access, expensive modification
Can we combine the advantages of them?
Extend each node by a timestamped modification box
A modification box holds at most one modification
When modification box is full, copy the node and apply the modification
Cascade change to the node‘s parent

75. Node Copying 5 1 7 3 version 0 k mbox lp rp version 1: Insert (2)

76. Node Copying 5 1 7 3 version 0: version 1: Insert (2) 2
1 lp 2
edit modification box directly
like fat nodes

77. Node Copying 5 1 7 3 3 version 1: Insert (2) version 2: Insert (4) 2 4
1 lp
1 lp 2 4
copy the node to be modified

78. Node Copying 5 1 7 3 3 version 1: Insert (2) version 2: Insert (4) 2 4
1 lp 2 4
apply the modification in modification box

79. Node Copying 5 1 7 3 3 version 1: Insert (2) version 2: Insert (4) 2 4
1 lp 2 4
perform new modification directly
the new node reflects the latest status

80. Node Copying 5 1 7 3 3 version 1: Insert (2) version 2: Insert (4) 2 4
2 rp 3 3
version 1:
Insert (2)
version 2:
Insert (4)
1 lp 2 4
cascade the change to its parent
like path copying

81. Node Copying Modification if modification box empty, fill it
otherwise, make a copy of the node, using the latest values
cascade this change to the node’s parent (which may cause node copying recursively)
if the node is a root, add a new root
Access
search for the correct root, check modification box
Complexity (Suppose m modifications)
Time
Space
Modification
Amortized: O(1)
Access
O(log m) +
O(1) per node

82. Applications: Grounded 2-Dimensional Range Searching
Problem
Given a set of n points and a query triple (a,b,i)
Report the set of points (x,y), where a<x<b and y<i y i a b x

83. Applications: Grounded 2-Dimensional Range Searching
Resolution
Consider each y value as a version, x value as a key
Insert each node in ascending order of y value
Version i contains every point for which y<i
Report all points in version i whose key value is in [a,b]

84. Applications: Grounded 2-Dimensional Range Searching
Resolution
Consider each y value as a version, x value as a key
Insert each node in ascending order of y value
Version i contains every point for which y<i
Report all points in version i whose key value is in [a,b] i a b
Preprocessing
Space required O(n) with Node Copying and O(n log n) with Path Copying
Query time O(log n)