1. Rank-Pairing Heaps Bernhard Haeupler, Siddhartha Sen, and Robert Tarjan, ESA 2009 1

2. Observation Computer science is (still) a young field. We often settle for the first (good) solution. It may not be the best: the design space is rich. 2

3. 3 Research Agenda For fundamental problems, systematically explore the design space to find the best solutions, seeking elegance: “ a quality of neatness and ingenious simplicity in the solution of a problem (especially in science or mathematics).”  wordnet.princeton.edu/perl/webwn Keep the design simple, allow complexity in the analysis.

4. Heap (Priority Queue) Problem Maintain a set (heap) of items, each with a real-valued key, under the operations Find minimum: find the item of minimum key in a heap Insert: add a new item to a heap Delete minimum : remove the item of minimum key Meld: Combine two item-disjoint heaps into one Decrease key: subtract a given positive amount from the key of a given item in a known heap Goal: O(log n) for delete min, O(1) for others

5. Related Work Fibonacci heaps achieve the desired bounds (Fredman & Tarjan, 1984); so do Peterson’s heaps (1987) Høyer’s heaps (1995) Brodal’s heaps (1996), worst-case Thin heaps (Kaplan & Tarjan, 2008) Violation heaps (Elmasry, 2008) Quake heaps (Chan, 2009) Not pairing heaps:  (loglog n) time per key decrease, but good in practice

6. Heap-ordered model Half-ordered model 11 1713 8 7 45 3

7. Half-ordered model 11 17 13 8 7 45 3

8. Half-ordered model 1117 7 5 3 13 8 4

9. Half-ordered tree: binary tree, one item per node, each item less than all items in left subtree Half tree: half-ordered binary tree with no right subtree Link two half trees: O(1) time, preserves half order 5 10 AB A 5 B +

10. Heap: a set (circular singly-linked list) of half trees, with minimum root first on list; access via last on list Find min: return minimum Insert: Form a new one-node tree, combine with current set of half trees, update the minimum Meld: Combine sets of half trees, update the minimum Delete min: Remove minimum root (forming new half trees); Repeatedly link half trees, form a set of the remaining trees

11. How to link? Use ranks: leaves have rank zero, only link trees whose roots have equal rank, increase winner’s rank by one: All rank differences are 1: a half tree of rank k is a perfect binary tree plus a root: 2 k nodes, rank = lg n + k k - 1 k k k + 1 Vuillemin’s binomial queues!

12. Delete minimum Delete min Each node on right path becomes a new root

13. Link half trees of equal rank Array of buckets, at most one per rank Delete min

14. Link half trees of equal rank Array of buckets, at most one per rank Form new set of half trees “multipass”

15. Delete min Form new set of half treesFind new minimum in O(log n) time

16. Keep track of minimum during links Find minimum in O(log n) additional time Delete min: lazier linking “one-pass”

17. Form new set of half trees Delete min: lazier linking

18. Amortized Analysis of Lazy Binomial Queues  = #trees Link: O(1) time,  = -1, amortized time = 0 Insert: O(1) time,  = 1 Meld: O(1) time,  = 0 Delete min: if k trees after root removal, time is O(k), potential decreases by k/2 – O(log n)  O(log n) amortized time

19. Decrease key? Application: Dijkstra’s shortest path algorithm, others Method: To decrease key of x, detach its half tree, restructure if necessary (If x is the right child of u, no easy way to tell if half order is violated) u x y u y x

20. How to maintain structure? All previous methods, starting with Fibonacci heaps, change ranks and restructure Some, like Quake heaps (Chan, 2009) and Relaxed heaps (Driscoll et al., 1988), do not restructure during key decrease, but this just postpones restructuring But all that is needed is rank changes: Trees can have arbitrary structure! Rank-Pairing Heaps = rp-heaps Goal is SIMPLICITY

21. 21 Node Ranks Each node has a non-negative integer rank Convention: missing nodes have rank -1 (leaves have rank 0) rank difference of a child = rank of parent - rank of child i-child: node of rank difference i i,j-node: children have rank differences i and j Convention: the child of a root is a 1-child

22. 1 Rank Rules Easy-to-analyze version (type 2): All rank differences are non-negative If rank difference exceeds 2, sibling has rank difference 0 If rank difference is 0, sibling has rank difference at least 2 Simpler but harder-to-analyze version (type 1): If rank difference exceeds 1, sibling has rank difference 0 If rank difference is 0, sibling has rank difference ≥ 1 1 12210≥ 2 0 110≥ 1 0

23. Tree Size If n k is minimum number of descendants of a node of rank k, n 0 = 1, n k = n k-1 + n k-2 : Fibonacci numbers n k ≥  k,  = k  log  n

24. 2 0 10 2 Decrease key x u 06 60 8 0 1 k - 1 1 1 k 1 y Detach half treeRestore rank rule 8 0 u 02 6 u 11 6 u 05 u k - 1 u 0-children block propagation of rank decreases from sibling’s subtree

25. Amortized Analysis Potential of node = sum of rank differences of children - 1 +1 if root (= 1) -1 if 1,1-node (= 0) Link is free: One unit pays for link Insert needs 1 unit, meld none + 1 (+1) (0) 11 11

26. Delete min rank k Each 1,1 needs potential 1, adding at most k in total. Delete min takes O(log n) amortized time 1 1 unit needed 1 0≥ 2 12

27. Decrease Key Successive rank decreases are non-increasing At most two 1,1’s occur on path of rank decreases – 1,1 becomes 0, j : prev decrease >1, next decrease = 1 1,1 becomes 1,2 : terminal Give each 1,1 one extra unit of potential Each rank decrease releases a unit to pay for decrease: rank diffs of both children decrease by k, rank diff of parent increases by k

28. 1 2 1 064 511 0 5 13 1 7 17 1 2 2 0 10 Decrease key 9 06 60 8 0 1 k - 1 1 1 k 1 Detach half treeRestore rank rule 8 0 02 6 11 6 05 k - 1 1

29. Type-1 rp-heaps Max k  lg n Analysis requires a more elaborate potential based on rank differences of children and grandchildren Same bounds as type-2 rp-heaps, provided we preferentially link half trees from disassembly

30. Summary Rank-pairing heaps combine performance guarantees of Fibonacci heaps with simplicity approaching pairing heaps Type-1 rp-heaps are especially simple, but not simple to analyze Results build on prior work by Peterson, Høyer, and Kaplan and Tarjan, and may be the natural conclusion of this work Simpler methods of doing key decrease are not efficient (see paper) Preliminary experiments show rp-heaps are competitive with pairing heaps on typical input sequences, and better on worst-case sequences

31. Additional Questions One-tree version of rp-heaps? Yes, but unfair links add losers to the bottom of the loser list instead of the top Decrease key without cascading rank changes? No, with O(log n) time per delete min Maybe, with O(log m) time per delete min need at least one rank decrease Simplify Brodal’s heaps?