Kinetic Medians and kd-trees

Transcription

1 Kinetic Medians and kd-trees Pankaj K. Agarwal 1,JieGao 2, and Leonidas J. Guibas 2 1 Department of Computer Science, Duke University, Durham, NC 27708, USA pankaj@cs.duke.edu 2 Department of Computer Science, Stanford University, Stanford, CA 94305, USA fjgao, guibasg@cs.stanford.edu Abstract. We propose algorithms for maintaining two variants of kd-trees of a set of moving points in the plane. A pseudo kd-tree allows the number of points stored in the two children to differ by a constant factor. An overlapping kd-tree allows the bounding boxes of two children to overlap. We show that both of them support range search operations in O(n 1=2+ffl ) time, where ffl only depends on the approximation precision. As the points move, we use event-based kinetic data structures to update the tree when necessary. Both trees undergo only a quadratic number of events, which is optimal, and the update cost for each event is only polylogarithmic. To maintain the pseudo kd-tree, we develop algorithms for computing an approximate median level of a line arrangement, which itself is of great interest. We show that the computation of the approximate median level of a set of lines or line segments can be done in an online fashion smoothly, i.e., there are no expensive updates for any events. For practical consideration, we study the case in which there are speed-limit restrictions or smooth trajectory requirements. The maintenance of the pseudo kd-tree, as a consequence of the approximate median algorithm, can also adapt to those restrictions. 1 Introduction Motion is ubiquitous in the physical world. Several areas such as digital battlefields, air-traffic control, mobile communication, navigation system, geographic information systems, call for storing moving objects into a data structure so that various queries on them can be answered efficiently; see [23, 25] and the references therein. The queries might relate either to the current configuration of objects or to a configuration in the future in the latter case, we are asking to predict the behavior based on the current information. In the last few years there has been a flurry of activity on extending the capabilities of existing database systems to represent moving-object databases (MOD) and on indexing moving objects; see, e.g., [14, 22, 23]. The known data structures for answering range queries on moving points either do not guarantee a worst-case bound on the query time [26, 25, 19] or are too complicated [1, 15]. In this paper we develop kinetic data structures for kd-trees, a widely used data structure for answering various proximity queries in practice [10], which can efficiently answer range queries on moving points. The kinetic data structure framework, originally proposed by Basch et al. [5], has led to efficient algorithms for several geometric

2 problems involving moving objects; see [13] and references therein. The main idea in the kinetic framework is that even though the objects move continuously, the relevant combinatorial structure of the data structure changes only at certain discrete times. Therefore one does not have to update the data structure continuously. The kinetic updates are performed on the data structure only when certain kinetic events occur; see [5, 13] for details. Recall that a kd-tree on a set of points is a binary tree, each node v of which is associated with a subset S v of points. The points in S v are partitioned into two halves by a vertical or horizontal line at v and each half is associated with a child of v. The orientation of the partition line alternates as we follow a path down the tree. In order to develop a kinetic data structure for kd-trees, the first step is to develop a kinetic data structure for maintaining the median of a set of points moving on a line. In fact, this subroutine is needed for several other data structures. Related work. The problem of maintaining the point of rank k in a set S of points moving on the x-axis is basically the same as computing the k-level in the arrangement of curves; the k-level in an arrangement of x-monotone curves is the set of edges of the arrangement that lie above exactly k curves [4]. If the points in S are moving with fixed speed, i.e., their trajectories are lines in the xt-plane, then the result by Dey [11] implies that the point of rank k changes O(nk 1=3 ) times; the best-known lower bound is ne Ω(p log k) [24]. Only much weaker bounds are known if the trajectories of points are polynomial curves. Edelsbrunner and Welzl [12] developed an algorithm for computing a level in an arrangements of lines. By combining their idea with kinetic tournaments proposed by Basch et al. [6] for maintaining the maximum of a set of moving points on a line, one can construct an efficient kinetic data structure for maintaining the median of a set of moving points. Since no near-linear bound is known on the complexity of a level, work has been done on computing an approximate median level. A ffi-approximate median-level is defined as a x-monotone curve that lies between (1=2 ffi)n- and(1=2 + ffi)n-levels. Edelsbrunner and Welzl [12] showed that a ffi-approximate median level with at most d (n)=(ffin)e edges, where (n) is the number of vertices on the median level of the arrangement, can be computed for line arrangements. Later Matoušek [16] proposed an algorithm to obtain a ffi-approximate median level with constant complexity for an arrangement of n lines. However no efficient kinetic data structure is known for maintaining an approximate median of a set of moving points. Because of their simplicity, kd-trees are widely used in practice and several variants of them have been proposed [3, 7, 17]. It is well known that a kd-tree can answer a two-dimensional orthogonal range query in O( p n + k) time, where k is the number of points reported. Variants of kd-trees that support insertions and deletions are studied in [18, 9]. No kinetic data structures are known for kd-trees. Agarwal et al. [1] were the first to develop kinetic data structures for answering range-searching queries on moving points. They developed a kinetic data structure that answers a two-dimensional range query in O(log n+k) time using O(n log n=(log log n)) space, where k is the output size. The amortized cost of a kinetic event is O(log 2 n),

3 and the total number of events is O(n 2 ). 1 They also showed how to modify the structure in order to obtain a tradeoff between the query bound and the number of kinetic events. Kollios et al. [15] proposed a data structure for range searching among points moving on the x-axis, based on partition trees [3]. The structure uses O(n) space and answers queries in O(n 1=2+ffl +k) time, for an arbitrarily small constant ffl>0.agarwalet al. [1] extended the result to 2D. Unlike kinetic data structures, these data structures are time oblivious, in the sense that they do not evolve over time. However all these data structures are too complex to be used in practice. In the database community, a number of practical methods have been proposed for accessing and searching moving objects (see [26, 25, 19] and the references therein). Many of these data structures index the trajectories of points either directly or by mapping to higher dimensions. These approaches are not efficient since trajectories do not cluster well. To alleviate this problem, one can parametrize a structure such as the R- tree, which partitions the points but allows the bounding boxes associated with the children of a node to overlap. To expect good query efficiency, the areas of overlap and the areas of the bounding boxes must be small. Although R-tree works correctly even when the overlap areas are too large, the query performance deteriorates in this case. Kinetic data structures based on R-tree were proposed in [25, 20] to handle range queries over moving points. Unfortunately, these structures also do not guarantee sublinear query time in the worst case. Our results. Let S = fp 1 ;:::;p n gbeasetofn points in R 1, each moving independently. The position of a point p i at time t is given by p i (t).weuseμp i = S t (p i(t);t)to denote the graph of the trajectory of p i in the xt-space. The user is allowed to change the trajectory of a point at any time. For a given parameter ffi > 0, we call a point x, not necessarily a point of S, affi-approximate median if its rank is in the range [(1=2 ffi)n; (1=2 + ffi)n]. We first describe an off-line algorithm that can maintain a ffi-approximate median of S in a total time of O((μ=(n 2 ffi 2 )+1=ffi)n log n), whereμ is the number of times two points swap position. We then show how a ffi-median can be maintained on-line as the points of S move. Our algorithm maintains a point x Λ on the x-axis, not necessarily one of the input points, whose rank is in the range (1=2±ffi)n.As the input points move, x Λ also moves, and its trajectory depends on the motion of input points. We show that the speed of this point is not larger than the fastest moving point, and that our algorithm can be adapted so that the trajectory of x Λ is C k -continuous for any k 0. Next, let S beasetofn points in R 2, each moving independently. We wish to maintain the kd-tree of S, sothatrange searching queries, i.e., given a query rectangle R at time t, report js(t) Rj, can be answered efficiently, Even if the points in S are moving with fixed velocity, the kd-tree on S can change (n 2 ) times, and there are point sets on which many of these events can cause a dramatic change of the tree, i.e., each of them requires Ω(n) time to update the tree. We therefore propose two variants of kd-trees, each of which answers a range query in time O(n 1=2+" + k), for any constant 1 Agarwal et al. [1] actually describe their data structure in the standard two level I/O model, in which the goal is to minimize the memory access time. Here we have described their performance in the standard pointer-machine model.

4 ">0,(k is the number of points reported), processes quadratic number of events, and spends polylogarithmic (amortized) time at each event. The first variant is called the ffi-pseudo kd-tree, in which if a node has m points stored in the subtree, then each of its children has at most (1=2 +ffi)mpoints in its subtree. In the second variant, called ffi-overlapping kd-tree, the bounding boxes of the points stored in the subtrees of two children of a node can overlap. However, if the subtree at a node contains m points, then the overlapping region at that node contains at most ffim points. As the points move, both of the trees are maintained in the standard kinetic data structure framework [5]. The correctness of the tree structure is certified by a set of conditions, called certificates, whose failure time is precomputed and inserted into an event queue. At each certificate failure, denoted as an event, the KDS certification repair mechanism is invoked to repair the certificate set and possibly the tree structure as well. In the analysis of a KDS, we assume the points follow pseudo-algebraic motions. By this we mean that all certificates used by the KDS can switch from TRUE to FALSE at most a constant number of times. In some occasions, we may make stronger assumptions, like the usual scenario of linear, constant velocity motions. For both pseudo and overlapping kd-trees, we show that the set of certificates has linear size, that the total number of events is quadratic, and that each event has polylogarithmic amortized update cost. Dynamic insertion and deletion are also supported with the same update bound as for an event. The pseudo kd-tree data structure uses our ffi-approximate median algorithms as a subroutine. Unlike pseudo kd-trees, the children of a node of an overlapping kdtree store equal number of points and the minimum bounding boxes of the children can overlap. However, maintaining overlapping kd-trees is somewhat simpler, and the analysis extends to pseudo-algebraic motion of points. 2 Maintaining the Median 2.1 Off-line maintenance Matoušek [16] used a level shortcutting idea to compute a polygonal line, with complexity O(1=ffi 2 ),whichisaffi-approximate median. Here we extend his idea to a set S of line segments in the plane. Let μ denote the number of intersection points between the segments. We divide the plane by vertical lines l i s into strips such that there are at most ffi 2 n 2 =16 intersections and at most ffin=4 endpoints inside each strip. In addition, we can assume that each strip either has exactly ffi 2 n 2 =16 intersections or exactly ffin=4 endpoints, otherwise we can always enlarge the strip. The number of strips is O(μ=(n 2 ffi 2 )+ 1=ffi). Along each l i, we compute the median X i of the intersections between S and l i. We connect adjacent medians. We claim that the resulting polygonal line is a ffiapproximate median level. Indeed, consider a strip bounded by l i and l i+1.wefirst delete the segments of S that have at least one endpoint inside the strip. Let U S be the set of line segments that intersect the segment X i X i+1 and that lie above X i at l i. Similarly let V S be the set of line segments that intersect X i X i+1 and that lie below X i at l i. ju j = u, jv j = v. SinceX i and X i+1 are on the exact median level and we

5 have deleted at most ffin=4 segments, ju vj» ffin=4. Suppose u» v» u + ffin=4. The intersection of a segment in U and a segment in V must be inside the strip (see Figure 1 (i)), therefore uv» ffi 2 n 2 =16, thereby implying that u» ffin=4 and v» ffin=2. X i X i+1 X i+1 X i X i+2 X 0 i+1 l i l i+1 l i l i+1 l i+2 (i) Fig. 1. (i) Approximate median level of n lines; (ii)when points change motion plan. (ii) Consequently, X i X i+1 is intersected at most ffin times, and thus it is a ffi-approximation of the median level between l i and l i+1. Computing the partition line l i involves computing the kth leftmost intersection in an arrangement. This can be done in O(n log n) time, using the slope-selection algorithm [8]. Computing a median along a cut line costs O(n). So the total computational cost is O((μ=(n 2 ffi 2 )+1=ffi)n log n). Theorem 1. Let S be a set of n segments in the plane with a total of μ intersection points. A ffi-approximate median level of S with at most O(μ=(n 2 ffi 2 )+1=ffi) vertices can be computed in O((μ=(nffi 2 )+n=ffi) log n) time. 2.2 On-line maintenance In previous subsection we assume that we know the motion plan of the points beforehand and compute the approximate median ahead of time. However, when the points change their motion plan, we want to maintain the approximate median online and distribute the amount of work more uniformly over time. Assume that the total number of motion plan changes over time is only linear in the number of points. We will show that the approximate median can be maintained smoothly, with linear number of events and polylogarithmic time update cost per event. Consider the time-space plane. As in Theorem 1, the plane is divided by vertical lines l i at time t i into strips. We maintain the invariant that each strip either contains at most ffi 2 n 2 =36 vertices or ffin=3 flight plan changes. Also if the strip contains less than ffin=3 flight plan changes, then it contains at least ffi 2 n 2 =72 vertices. We approximate the median level by computing a polygonal line X 1 X 2 :::X m in which X i lies on l i.we can see that the total number of strips is bounded by O(1=ffi 2 ) since there are only linear number of flight plan changes in total. However, instead of computing the O(1=ffi 2 ) cut lines all at one time, we compute them one by one. We begin with computing the median on the two leftmost cut lines l 1 and l 2 (l 1 corresponds to the starting time). There are ffi 2 n 2 =72 vertices between l 1 and l 2. The approximate median then moves along line segment X 1 X 2. This preprocessing

6 costs O(n log n). Then we compute the position of the cut line l i+2 and the median along l i+2 gradually, as we are moving along X i X i+1. The position of l i+2 is computed such that there are ffi 2 n 2 =72 vertices between l i+1 and l i+2.sox i+2 is our prediction of the median on l i+2, assuming there is no flight plan change between t i+1 and t i+2. The cost of computing l i+2 and X i+2, which is a slope-selection problem, is amortized over the time interval [t i ;t i+1 ], using the technique proposed by Agarwal et al. [2]. In an online version, we need to accommodate the flight plan changes in the future. If there are ffin=6 motion plans changes before we reach l i+1, we start another session to compute X i+2 based on the current (changed) trajectories. If we reach X i+1 before another ffin=6 motion updates, we switch to the segment X i+1 X i+2 computed from the first construction. Otherwise, if we see another ffin=6 motion plan changes (i.e., a total of ffin=3 changes since t i ) before we reach l i+1, then we just stop and move l i+1 to the current position and X i+1 to the current position of the approximate median. The next line segment that the approximate median needs to follow is X i+1 X i+2,wherex i+2 is the value returned by the second computation (the one initiated after ffin=6 motion-plan changes). Thus inside one strip, the number of intersections is at most ffi 2 n 2 =36,andthe number of flight plan changes is at most ffin=3. Next we prove that the polygonal line we compute is a ffi-approximation of the median level. The only problem is that if some points change their flight plans between time t i and t i+1,thenx i+1, which is computed before t i, is no longer the real median X 0 i+1.see Figure 1 (ii). However, only the points between X i+1 and X 0 i+1 can cross X i+1x i+2 without crossing X 0 i+1 X i+2. Since there are only at most ffin=3 flight plan changes, there are at most ffin=3 points between X i+1 and X 0 i+1.sincex0 i+1 X i+2 is crossed by at most 2ffin=3 lines, X i+1 X i+2 is still a ffi-approximation. Theorem 2. Let S be a set of n points, each moving with a constant velocity. Suppose the flight paths of S change a total of m times. Then a ffi-approximate median of S can be maintained in an online fashion so that the median moves continuously with at most O(1=ffi 2 ) flight plan changes. The total maintenance cost is O((n + m) log n=ffi 2 ).Each flight plan change costs polylogarithmic update time. Remark. Finding the next cut line in Theorem 2 is based on complex algorithms and data structures (e.g., slope selection). We can use a considerably simpler randomized algorithm, based on the random-sampling technique, for computing the next cut line. We omit the details from this version of the paper. 2.3 Approximate median with speed limit In many applications like mobile networks and spatial databases, the maximum velocity of the points is restricted. We ll show an approximate median that moves no faster than the fastest point. Lemma 1. The approximate median computed above cannot move faster than the maximum speed of the n points, if the points do not change flight plans. Proof. Observe that the approximate median is composed of line segments connecting two median points X and Y at different time steps. So if there is a line l crossing XY

7 and going up, there must be another line l 0 crossing XY and going down. So the slope of XY is bounded by the slope of l and l 0.IfXY is not crossed by any lines, X and Y lie on the same line as they are both medians. Hence, the approximate median moves along one of the input points between X and Y. This proves the lemma. If the points can change their flight plan, our scheme in Theorem 2 does not guarantee that the approximate median moves within the limit restriction. But we can adapt it as follows. Let X i and Xi 0 denote the precomputed and exact median, respectively. We let the approximate median to move toward the precomputed median. If we can reach there without violating the speed constraint, then everything is fine. Otherwise, we just move toward it with the maximum speed. Figure 2 (i) shows the second case. W.l.o.g., X ik+2 X ik+3 X i+1 X i 00 Xi+2 X i+2 X ik X 0 i+1 X 0 i+2 X ik+1 X (i+1)k l i l i+1 l i+2 (i) (ii) Fig. 2. (i) Speed restricted median; (ii) Smooth medians. we assume X i+1 is above X 0 00 i+1. Assume the approximate median gets to the point Xi+2 at time t i+2. Since the approximate median moves with the maximum speed, the points above X i+1 will stay above X 00 i+2.soatmostffin=3 points, the ones that lie between X i+1 and X 0, can cross i+1 X i+1x 00 without crossing i+2 X 0 i+1 X i+2. Following the argument in Theorem 2, X 0 i+1 X i+2 is crossed by at most 2ffin=3 lines. So X i+1 X 00 is a i+2 ffi-approximate median level. There are n=2 points below X 0 and i+1 X 0, respectively, i+2 so the number of points between X 00 and i+2 X 0 i+2 can only be less than the number of points between X i+1 and X 0 i+1. This imples that we can continue this process for the next time interval and we obtain the following result. Theorem 3. Let S bea setofnpoints, eachmovingwith fixedvelocity. We canmaintain a ffi-approximate median of S that preserves all the properties of Theorem 2 and that cannot move faster than the maximum speed of the input points. 2.4 Smooth medians For a set of moving points, the approximate median we computed above, follows a polygonal line composed of line segments. Although the approximate median moves continuously, it may have to make sharp turns. In practice, a smooth trajectory is preferred. A curve is said to have C k continuity if its k-th derivative is continuous. The idea is to use Bézier interpolation on the medians along the vertical lines, see Figure 2 (ii). We will give the theorem whose proof is omitted.

8 Theorem 4. Given an arrangement of n lines in the plane, we can compute a curve with C k continuity which is a ffi-approximate median level. The curve is determined by O(k 2 =ffi 2 ) control points and is computed in O(k 2 n log n=ffi 2 ) time. 3 Pseudo kd-tree Overmars [18] proposed the pseudo kd-tree as a dynamic data structure for range searching that admits efficient insertion and deletion of points. Definition. A ffi-pseudo kd-tree is defined to be a binary tree created by alternately partitioning the points with vertical and horizontal lines, so that for each node v with m points in the subtree, there are at most (1=2 +ffi)mpoints in the subtrees rooted at the children of v. Affi-pseudo kd-tree is an almost balanced tree with depth log 2=(1+2ffi) n. We denote by d(u) the depth of a node u. The same analysis as for the standard kd-tree implies that a range query in a ffi-pseudo kd-tree can be answered in O(n 1=2+" + k) time, k is the number of points in the answer and " = log (1=2+ffi) 2 2 1=2. Maintaining the pseudo kd-tree. One way to maintain the pseudo kd-tree is to maintain the input points sorted by their x- aswellasy-coordinates and update the tree when a point crosses the partition line. Maintaining the points in two sorted lists will generate (n 2 ) events. The subtree is rebuilt if the number of points in one child exceeds fraction 1=2 + ffi. Each event has an amortized update cost of O(log n). Another way of maintaining the pseudo kd-tree is to use the dynamic data structure proposed by Overmars [18]. However, it maintains a forest of kd-trees instead of a single tree. Here, we will show how to maintain a single kd-tree with only polylogarithmic update cost per event without any rebuilding,assume the points move with constant velocity. To maintain a pseudo kd-tree, we need to maintain a hierarchical partition of the points, which always supports a ffi-pseudo kd-tree. Since points are inserted into or deleted from a subtree, the trajectories of the points stored in a node are actually line segments. Maintaining the partition line of a node involves finding the approximate median of a set of line segments in an online fashion. The idea for online maintenance in Section 2.2 works here as well. The difference is, points may come in and out of the range of a node. So inside one strip the number of intersections, endpoints of the line segments and flight plan changes should be bounded all at the same time. The endpoints of the line segments can be treated in the same way as the events of motion plan changes we described before. We omit the details here and prove the following lemma and theorem in an off-line setting. We define a ffi-approximate partition line of depth k to be a ffi-approximate median level in the arrangement of the trajectories of points stored in the subtree of a node at depth k.letv k denote the set of nodes at depth k. Lemma 2. There exists a set of ffi-approximate partition lines of V k with total complexity O(k=(ffiff k ) 2 ), and it can be computed in O((kn log n)=(ffiff k ) 2 ) time, where ff =1=2 ffi.

9 Proof. A key observation is that the combination of the trajectories of all the points in V k is the arrangement of n lines. So the total number of intersections of the segments in V k is bounded by O(n 2 ). Assume a node of depth k has n k points associated with it. Since the child of a node with m points has at least (1=2 ffi)m points, we have n k nff k where ff =1=2 ffi.lets k be the total number of line segments in V k,and let c k be the total complexity of the ffi-approximate partition lines for V k. By Theorem 1, we have that c k = O((n=(ffin k )) 2 + s k =(ffin k )). When a point crosses the partition line at a node of depth k, it ends the trajectory in the old child and begins a trajectory in the new child. Therefore we have s k+1 =2c k ffin k = O(n 2 =(ffin k ))+2s k. By induction, we get s k = O(kn=(ffiff k )), c k = O(k=(ffi 2 ff 2k )). The running time is bounded in the same way as in Theorem 1. An event happens when a point crosses a partition line. Updating the pseudo tree involves moving a point from one subtree to the other, which costs log 2=(1+2ffi) n.the number of events of depth k is bounded by s k+1 =2. So the total number of events is O((n 2 =ffi) log 2=(1+2ffi) n). In summary, we have Theorem 5. For a set of n moving points on the plane, each moving with a constant velocity, we can find a moving hierarchical partition of the plane which supports a ffi-pseudo kd-tree at any time. The number of events in the kinetic data structure is O((n 2 =ffi) log 2=(1+2ffi) n) in total. Update cost for each event is O(log 2=(1+2ffi) n). 4 Overlapping kd-tree In the second variant of the kd-tree, the bounding boxes associated with the children of a node can overlap. Definition. Assume S(v) is the set of points stored in the subtree of a node v, B(v) is the minimum bounding box of S(v),andd(v) is the depth of v.defineff(w) =B(u) B(v)to be the overlapping region of two children u and v of node w. Affi-overlapping kd-tree is a perfectly balanced tree so that for each node w with m points in the subtree, there can be at most ffim points in the overlapping region ff(w), 0 < ffi < 1. The overlapping kd-tree has linear size and depth O(log n). We call a node x-partitioned (y-partitioned) if it is partitioned by a vertical (resp. horizontal) line. An orthogonal range query can be answered in the same way as in the standard kd-tree. Lemma 3. Let ` be a vertical (or horizontal) line, and let v, w be two x-partitioned (y-partitioned) nodes of a ffi-overlapping kd-tree such that w is a descendant of v. If` intersects both ff(v) and ff(w), thend(w) d(v) + log 2 fl,wherefl =(1 2ffi)=(2ffi). Theorem 6. A range query in a ffi-overlapping kd-tree can be answered in O(n 1=2+" + k) time, where " = log fl 2, fl =(1 2ffi)=(2ffi), k is the number of points reported. Proof. As for the standard kd-tree, it suffices to bound the number of nodes whose bounding boxes intersect a vertical line `. Letv be a x-partitioned node at depth k, and let n v be the points stored in the subtree rooted at v. The query procedure visits bothchildrenandthusall fourgrandchildrenof v onlyif ` intersects ff(v).otherwise,`

10 intersects at most two grandchildren of v. The granchildren of v are also x-partitioned. By Lemma 3, ` does not intersect ff(w) for any descendent w of v at depth less than k + log 2 fl. An easy calculation shows that ` intersects at most 8 p fl nodes of depth at most k + log 2 fl and at most 2 p fl nodes of depth k + log 2 fl. On the other hand, any descendent of v at depth k + log 2 fl has at most n v =fl points. Let C(n v ) denote the number of nodes intersected by ` in the subtree rooted at a x-partitioned node that contains at most n v points. Then we obtain the following recurrence C(n v )» 2 p flc(n v =fl) +8 p fl whose solution is C(n v )=O(n 1=2+" v ),where" = log fl 2. Maintaining the overlapping kd-tree. Maintaining the ffi-overlapping kd-tree mainly involves tracking the number of points in the overlapping region. Consider the root of the kd-tree, assume n points are divided into n=2 red points and n=2 blue points by a vertical line at the beginning. W.l.o.g, assume red points have bigger coordinates. Consider the time-space plane, the goal is to track the depth of the lower(upper) envelope of red(blue) curves in the arrangement of blue(red) curves. An event happens when those two numbers add up to ffin. So at least ffin=2 points in the overlapping region have the same color, suppose they are red. Then the highest blue point must be above at least ffin=2 red points. We define a red-blue inversion to be the intersection of a red curve and a blue curve. So there must be at least Ω(ffin) red-blue inversions since the last recoloring. The number of recoloring events in the root of the kd-tree is bounded by O(n=ffi), if the points follow pseudo-algebraic motion. Since the combination of the trajectories of all the points in nodes of depth k becomes the arrangement of the trajectories of n points, the total number of recoloring events in depth k is bounded by O(n2 k =ffi), using the same argument as above. When an event happens at depth k, we rebuild the subtree, which costs O(n log n=2 k ).Sothe total update cost sumed up over all events is O(n 2 log n=ffi). The amortized cost for one event is therefore O(log n). Putting everything together, we obtain the following. Theorem 7. Let S be aset ofn pointsmovingin the plane, andletffi > 0bea constant. We can maintaina ffi-overlapping kd-tree by spending O(log n) amortized time at each event. Under pseudo-algebraic motion of S, the number of events is O(n 2 =ffi). Acknowledgements: The authors wish to thank John Hershberger and An Zhu for numerous discussions and for their contribution to the arguments in this paper. Research by all three authors is partially supported by NSF under grant CCR Research by P. Agarwal is also supported by NSF grants EIA , EIA , and CCR , and by a grant from the U.S. Israel Binational Science Foundation. Research by J. Gao and L. Guibas is also supported by NSF grant CCR and grants from the Stanford Networking Research Center, the Okawa Foundation, and the Honda Corporation. References 1. P. K. Agarwal, L. Arge, and J. Erickson. Indexing moving points. In Proc. Annu. ACM Sympos. Principles Database Syst.,

11 2. P. K. Agarwal, L. Arge, and J. Vahrenhold. Time responsive external data structures for moving points. In Workshop on Algorithms and Data Structures, pages 50 61, P. K. Agarwal and J. Erickson. Geometric range searching and its relatives. In B. Chazelle, J. E. Goodman, and R. Pollack, editors, Advances in Discrete and Computational Geometry, volume 223 of Contemporary Mathematics, pages American Mathematical Society, Providence, RI, P. K. Agarwal and M. Sharir. Arrangements and their applications. In J.-R. Sack and J. Urrutia, editors, Handbook of Computational Geometry, pages Elsevier Science Publishers B.V. North-Holland, Amsterdam, J. Basch, L. Guibas, and J. Hershberger. Data structures for mobile data. J. Alg., 31(1):1 28, J. Basch, L. J. Guibas, and G. D. Ramkumar. Reporting red-blue intersections between two sets of connected line segments. In Proc. 4th Annu. European Sympos. Algorithms, volume 1136 of Lecture Notes Comput. Sci., pages Springer-Verlag, J. L. Bentley. Multidimensional binary search trees used for associative searching. Communications of the ACM, 18(9): , R. Cole, J. Salowe, W. Steiger, and E. Szemerédi. An optimal-time algorithm for slope selection. SIAM J. Comput., 18(4): , W. Cunto, G. Lau, and P. Flajolet. Analysis of kdt-trees: kd-trees improved by local reorganisations. Workshop on Algorithms and Data Structures (WADS 89), 382:24 38, M. de Berg, M. van Kreveld, M. Overmars, and O. Schwarzkopf. Computational Geometry: Algorithms and Applications. Springer-Verlag, Berlin, T. K. Dey. Improved bounds on planar k-sets and k-levels. In IEEE Symposium on Foundations of Computer Science, pages , H. Edelsbrunner and E. Welzl. Constructing belts in two-dimensional arrangements with applications. SIAM J. Comput., 15: , L. J. Guibas. Kinetic data structures a state of the art report. In P. K. Agarwal, L. E. Kavraki, and M. Mason, editors, Proc. Workshop Algorithmic Found. Robot., pages A. K. Peters, Wellesley, MA, R. H. Güting, M. H. Böhlen, M. Erwig, C. S. Jensen, N. A. Lorentzos, M. Schneider, and M. Vazirgiannis. A foundation for representing and querying moving objects. ACM Trans. Database Systems, 25(1):1 42, G. Kollios, D. Gunopulos, and V. J. Tsotras. On indexing mobile objects. In Proc. Annu. ACM Sympos. Principles Database Syst., pages , J. Matoušek. Construction of ffl-nets. Discrete Comput. Geom., 5: , J. Nievergelt and P. Widmayer. Spatial data structures: Concepts and design choices. In J.-R. Sack and J. Urrutia, editors, Handbook of Computational Geometry, pages Elsevier Science Publishers B.V. North-Holland, Amsterdam, M. H. Overmars. The Design of Dynamic Data Structures, volume 156 of Lecture Notes Comput. Sci. Springer-Verlag, Heidelberg, West Germany, D. Pfoser, C. J. Jensen, and Y. Theodoridis. Novel approaches to the indexing of moving object trajectories. In Proc. 26th Intl. Conf. Very Large Databases, pages , C. M. Procopiuc, P. K. Agarwal, and S. Har-Peled. Star-tree: An efficent self-adjusting index for moving points. In Proc. 4th Workshop on Algorithm Engineering and Experiments, A. Rockwood and P. Chambers. Interactive Curves and Surfaces: A Multimedia Tutorial on CAGD. Morgan Kaufmann Publishers, Inc., A. P. Sistla and O. Wolfson. Temporal conditions and integrity constraints in active database systems. In Proceedings of the 1995 ACM SIGMOD International Conference on Management of Data, pages , A. P. Sistla, O. Wolfson, S. Chamberlain, and S. Dao. Modeling and querying moving objects. In Proc. Intl Conf. Data Engineering, pages , 1997.

12 24. G. Tóth. Point sets with many k-sets. Discrete & Computational Geometry, 26(2): , S. Šaltenis, C. S. Jensen, S. T. Leutenegger, and M. A. Lopez. Indexing the positions of continuously moving objects. In Proc. ACM SIGMOD International Conference on Management of Data, pages , O. Wolfson, A. P. Sistla, S. Chamberlain, and Y. Yesha. Updating and querying databases that track mobile units. Distributed and Parallel Databases, pages , 1999.