Kinetic Heaps K, Tarjan, and Tsioutsiouliklis

Broadcast Scheduling Parametric and Kinetic Heaps Broadcast Scheduling Using a Kinetic Heap The Computational Geometry View What is known Four New Structures Simple Heap Balanced Heap Fibonacci Heap Incremental Heap Open problems Outline

(Lecture by Mike Franklinresearch papers) Users One server, many possible items to send (say, all the same length) One broadcast channel. Users submit requests for items. Goal: Satisfy users as well as possible, making decisions on-line. (say, minimize sum of waiting times) Server: many data items Broadcast channel (single-item) Broadcast Scheduling

Greedy = Longest Wait first (LWF): Send item with largest sum of waiting times. R x W : send item with largest ( # requests x longest waiting time) Scheduling policies (vs. number of requests or longest single waiting time)  

5 Results of Franklin and others: LWF schedules well “in practice” (in simulations) but too expensive (linear-time) This claim used to justify approximations to R x W, still linear-time but with a smaller (parameterized) constant.

Questions (for an algorithm guy or gal) LWF does well compared to what? Try a competitive analysis Can we improve the cost of LWF?   What data structure? Open question 1 Will talk about this

A collection of items, each with an associated key. key (i) = a i x + b i a i,, b i reals, x a real-valued parameter a i = slope, b i = constant Operations: make an empty heap. insert item i with key a i x + b i into the heap: insert(i,a i,b i ) find an item i of minimum key for x = x 0 : find-min( x 0 ) delete item i : delete(i) Parametic Heap

A parametric heap such that successive x-values of find mins are non-decreasing. (Think of x as time.) x c = largest x in a find min so far (current time) Additional operation: decrease the key of an item i, replacing it by a key that is no larger for all x  x c : decrease-key(i,a,b) Kinetic Heap

Need a max-heap (replace find min by find max, decrease key by increase key, etc) Can implement LWF or R x W or any similar policy: Broadcast decision is find max plus delete Request is insert (if first) or increase key (if not) Only find max need be real-time, other ops can proceed concurrently with broadcasting Slopes are integers that count requests Broadcast scheduling via kinetic heap

LWF: Suppose a request for item i arrives at time t s If i is inactive then insert(i, t-t s ) If i is active with key at+b then increase-key(i, (a+1)t+(b-t s )) To broadcast an item at time t s we perform delete-max(t s ) and broadcast the item returned. Broadcast scheduling via kinetic heap (Cont.)

A key is a line  computational geometry Equivalent problems: maintain the lower envelope of a collection of lines in 2D projective duality maintain the convex hull of a set of points in 2D under insertion and deletion “kinetic” restriction = “sweep line” query constraint What is known about parametric and kinetic heaps?

Overmars and Van Leeuwen (1981) O( log n) time per query O(log 2 n) time per update, worst-case Chazelle (1985), Hershberger and Suri (1992) (deletions only) O( log n) time per query, worst-case O(n log n) for n deletions Results I

Results II Chan (1999) Dynamic hulls and envelopes O( log n) time per query O(log 1+  n) time per update, amortized Brodal and Jacob (2000) O( log n) time per query O( log n log log log n) time per insert, O( log n log log n) timer per delete, amortized

Results III Basch, Guibas, and Hershberger (1997) “Kinetic” data structure paradigm

Four different data structures, each one best in a different setting. Simple Heap Balanced Heap Fibonacci Heap Incremental Heap Our results

A balanced binary tree, with items in the leaves in left-right order by decreasing key slope. The tree is a tournament on items by current key. Simple heap (highlights) We get O(log 2 n) for delete and insert O(1) for find-min All bounds are amortized

A better deletions only data structure Dynamize using the technique of Bently and Saxe Balanced heap (highlights) We get O(log n loglog n) for delete O(log n) for find-min and insert

Based one Fibonacci heaps with lazy linking. We link only when it is safe Fibonacci heap (highlights) We get O(log 2 n) for delete O(log n) for find-min and insert O(log n) for decrease-key

Incremental heap (highlights) Assumptions insertion of i: a i = 1, increase key of i: a i := a i + 1 Group items by key slope, each group is an ordinary Fibonacci heap Move items among groups as key slopes change (“displaced” items because entire subtrees are moved) We get find-max, insert : O(1) The k th increase-key : O(log min{k,n}) delete : O(log n)

A balanced binary tree, with items in the leaves in left-right order by decreasing key slope. The tree is a tournament on items by current key. Simple heap (details)

a b e d c a b d c e a a c a       

Simple kinetic heaps (Cont) Add swap times at internal nodes

a b e d c a b d c e a a c a       

Simple kinetic heaps (Cont) Add minimum future swap time

a b e d c a b d c e a a c a       

Simple kinetic heaps (Cont) When we do a find-min if the current time moves forward, we act as follows: Locate all nodes whose winner changes. The paths from the root to those nodes form a subtree. Update this subtree

a b e d c a b d c e a a c a       

a b e d c a b d c e a a c a       

a b e d c a b d c e b a c a               

a b e d c a b d c e b b  20 3        c a

a b e d c a b d c e b b  20 3        c b

a b e d c a b d c e b b c b         6.8

a b e d c a b d c e b b c b        

a b e d c a b d c e b b e e         20 3 

a b e d c a b d c e b b e e         3  5 6.8

Simple kinetic heaps – insert & delete Use the regular mechanism of (say) red-black trees

a b e d c a b d c e b b e e f         

a b e d c a b d c e b b e e   f f f  -20       

a b e d c a b d c e b f e e     f f f  -20       

Simple kinetic heaps (analysis) Find-min takes O(1) time if we do not advance the current time. Advancing the current time can be expensive on the worst-case Amortization: Assign O(log n) potential to each node whose swap time is in the future. This potential pays for advancing the time. So find-min takes O(1) amortized time. Insert and delete take O(log 2 n) amortized time

How do we make this a parametric heap ? (Overmars-Van Leeuwen)

a b e d c a b c e        d

Looks like we use non linear space ? Each node keeps the chain of segments that are on its envelope but not on its parent envelope. This makes the space linear.

a b e d c a b c e        d

Analysis Using search trees to represent the envelopes sorted by slopes then: Find-min takes O(log n) time Insert and delete take O(log 2 n) time: You split and concatenate O(log n) such envelopes.

Balanced kinetic heaps Def: The level of a line is the depth of the highest node where it is stored. Plan: first we’ll do only deletions faster and then we’ll add insertions. Our starting point is the previous data structure.

Deletion-only data structure The level of a line is the depth of the highest node where it is stored.

a b e d c a b c e        d d

Deletion-only data structure What happens when we delete a line ?

a b e d c a b c e        d d

a b e d c a b e        d d

a b e d c a b e        d d

a b e d c a b e        d d

Balanced kinetic heaps When we delete a line, lines only decrease their level.

      

      

Analysis Key idea: Implement the envelopes using finger search trees How much time it takes to delete an element ? O(log n) +  log (# lines get on the replacement piece) +  log (# lines get off the replacement piece) If in all nodes # lines get on/off the replacement piece < log 2 n we are ok --- the delete takes O(log n loglog n) time However it could be that # lines get on/off the replacement piece > log 2 n

Analysis (Cont) If a line gets on the replacement piece it changes its level Since the total number of level changes is nlog(n) The number of chains of length > log 2 n is at most n/log(n) So the total work in moving long chain is O(n) and can be charged to the initialization phase.

A better deletions only data structure O(n) init. time and then O(log n loglog n) per delete. O(1) find-min if we are kinetic. Now we add insert. Summary so far

Balanced kinetic heaps (finalle) Balanced heaps (step 2): Use a well known reduction by Bently and Saxe to add insertions Maintain a binary counter of deletion only data structures

Balanced kinetic heaps Delete : O(log n loglog n) Insert : O(log n) Find-min : O(log n) (kinetic)

Based one Fibonacci heaps with lazy linking. We link only when it is safe Fibonacci heap (highlights) We get O(log 2 n) for delete O(log n) for find-min and insert O(log n) for decrease-key

Fibonacci Kinetic Heap Mimic Fibonacci heap, but only do links for permanent comparisons. Store unlinked tree roots of equal rank in a sorted list O(log n) find min, insert, decrease key, O(log 2 n) delete, amortized

Fibonacci heaps (Fredman & Tarjan 84) Want to do decrease-key(x,h,  ) faster than delete+insert. ( in O(1) time.)

Heap ordered (Fibonacci) trees

Linking Operations are defined via a basic operation, called linking, of Fibonacci trees: Produce a F k from two F k-1, keep heap order

Basic idea: delay the linking until they are safe S1S1 S0S0 SrSr  Regular heap

Linking The basic operation is inserting a tree of rank r into S r, making the appropriate linking if needed. Insert(i) : Insert a new node containing i into S 0 This may cascade, but we have one tree less every time we do the linking Decrease-key(i, a’.b’) : Decrease the key of i in the tree containing it making cascading cuts, link the resulting trees back into the structure.

Analysis Similar to the analysis of F-heaps Multiply the potential by log n

Incremental heap (highlights) Assumptions insertion of i: a i = 1, increase key of i: a i := a i + 1 Group items by key slope, each group is an ordinary Fibonacci heap Move items among groups as key slopes change (“displaced” items because entire subtrees are moved) We get find-max, insert : O(1) The k th increase-key : O(log min{k,n}) delete : O(log n)

Open problems Experiments: What is the best structure in practice? Better bounds: kinetic heaps in ordinary F-heap bounds? parametric heaps in O(log n) amortized time per operation? Simple kinetic heaps via splay trees?