1 / 36

Kinetic data structures

Kinetic data structures. Goal. Maintain a configuration of moving objects Each object has a posted flight plan (this is essentially a well behaved function of time). Example 1. Maintain the closest pair among points moving in the plane. Example 2.

bert-davis
Download Presentation

Kinetic data structures

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Kinetic data structures

  2. Goal • Maintain a configuration of moving objects • Each object has a posted flight plan (this is essentially a well behaved function of time)

  3. Example 1 Maintain the closest pair among points moving in the plane

  4. Example 2 Maintain the convex hull of points moving in the plane

  5. Elements of a KDS • An event queue (A heap of discrete times) • The event queue will contains all times where the combinatorial structure of the configuration may change • Like a “sweep” of the time dimension

  6. Example 3 Maintain the topmost among points moving along the y-axis

  7. Look at the ty-plane y t

  8. We are interested in the upper envelope y t

  9. Solution • Calculate this upper envelope ! • Sharir, Hart, Agarwal and others: • The complexity of the envelope is close to linear if any pair of function intersect at most s times • Can compute it in O(n log(n)) time

  10. Problem • If we would like to change a trajectory then we need to recompute te envelope • That takes O(nlog(n)) time • We want to be able to change a trajectory faster

  11. Another solution • Maintain the points sorted • For every pair of points put in the event queue the time when they switch order

  12. Example 3

  13. Problem • We process Ω(n2) events • But the configuration changes only linear (or close to linear) number of times…

  14. So what do we want from a KDS to be good • You maintain a set of certificates that as long as they are valid the configuration does not change. • Want: The number of times a certificate fails (internal events) to be small relative to the number of times the configuration changes (external events)  Efficient

  15. So what do we want from a KDS to be good (Cont) • Process a certificate failure fast  responsive • Small space  compact • Object participates in a small # of cetificates (can change trajectories easily)  local

  16. Dynamic KDS • Want also to be able to insert and delete objects efficiently

  17. So what would be a good solution for this problem ? Maintain the topmost among points moving along the y-axis

  18. A tournament tree d c b a c a d b

  19. A tournament tree d c b d a c d c a d b

  20. A tournament tree d c b d a c d c a d b For each internal node maintain in an event queue the next time where the children flip order

  21. d d c c d b a c a d b y t Processing of an event: Replace the winner and replace O(log(n)) events in the event queue Takes O(log2(n)) time  responsive Linear space  compact Each point participates in O(log n) events  local

  22. d c b a y t d r c 2 1 d c a d b What is the total # of events ? Events at r correpond to changes at the upper envelope, lets say there are O(n) Events at 1 correponds to change at the upper envelope of {b d}  O(n/2) … In total we get O(nlog(n)) events  efficient

  23. d c b a y t d r c 2 1 d c a d b Handeling insertions/deletions ? Use some kind of a balanced binary search tree Each node charges its events to the upper envelope of its subtree Without rotations we get O(nlog(n)) events

  24. d c b a y t d r c 2 1 d c a d b Handeling insertions/deletions Because of rotations each point participates in more than O(log n) envelopes Use a BB[alpha] tree  think of each pair of nodes participating in a rotation as new nodes, then the total size of envelopes corresponding to new nodes is O(nlog(n))

  25. d c b a y d r c 2 1 d t c a d b We’ll focus now a bit more at the case where the points move with constant velocity Can redefine the problem so we do not insist on maintaining the upper envelope explicitly at all times

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

  27. Kinetic Heap A parametric heap such that successive x-values of find maxs are non-decreasing. (Think of x as time.) xc = largest x in a find max so far (current time) Additional operation: increase the key of an item i, replacing it by a key that is no larger for all x > xc : increase-key(i,a,b)

  28. What is known about parametric and kinetic heaps? Equivalent problems: maintain the upper 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

  29. Results I Overmars and Van Leeuwen (1981) O( log n) time per query O(log2n) 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

  30. Results II Chan (1999) Dynamic hulls and envelopes O( log n) time per query O(log1+en) time per update, amortized Brodal and Jacob (2000), Kaplan, Tarjan, Tsioutsiouliklis (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

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

  32. Broadcast Scheduling requests Server: many data items Users Broadcast channel (single-item) 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)

  33. Scheduling policies 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) (vs. number of requests or longest single waiting time) -1 -4

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

  35. Broadcast scheduling via 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

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

More Related