Zahed Rahmati

A simple, faster method for kinetic proximity problems

For a set of n points in the plane, this paper presents simple kinetic data structures (KDSs) for solutions to some fundamental proximity problems, namely, the all nearest neighbors problem, the closest pair problem, and the Euclidean minimum spanning tree (EMST) problem. Also, the paper introduces KDSs for maintenance of two well-studied sparse proximity graphs, the Yao graph and the Semi-Yao graph.We use sparse graph representations, the Pie Delaunay graph and the Equilateral Delaunay graph, to provide new solutions for the proximity problems. Then we design KDSs that efficiently maintain these sparse graphs on a set of n moving points, where the trajectory of each point is assumed to be a polynomial function of constant maximum degree s. We use the kinetic Pie Delaunay graph and the kinetic Equilateral Delaunay graph to create KDSs for maintenance of the Yao graph, the Semi-Yao graph, all the nearest neighbors, the closest pair, and the EMST. Our KDSs use O ( n ) space and O ( n log ? n ) preprocessing time.We provide the first KDSs for maintenance of the Semi-Yao graph and the Yao graph. Our KDS processes O ( n 2 β 2 s + 2 ( n ) ) (resp. O ( n 3 β 2 s + 2 2 ( n ) log ? n ) ) events to maintain the Semi-Yao graph (resp. the Yao graph); each event can be processed in amortized time O ( log ? n ) . Here, β s ( n ) = λ s ( n ) / n is an extremely slow-growing function and λ s ( n ) is the maximum length of Davenport-Schinzel sequences of order s on n symbols.Our KDS for maintenance of all the nearest neighbors and the closest pair processes O ( n 2 β 2 s + 2 2 ( n ) log ? n ) events. For maintenance of the EMST, our KDS processes O ( n 3 β 2 s + 2 2 ( n ) log ? n ) events. For all three of these problems, each event can be handled in amortized time O ( log ? n ) .Our deterministic kinetic approach for maintenance of all the nearest neighbors improves by an O ( log 2 ? n ) factor the previous randomized kinetic algorithm by Agarwal, Kaplan, and Sharir. Furthermore, our KDS is simpler than their KDS, as we reduce the problem to one-dimensional range searching, as opposed to using two-dimensional range searching as in their KDS.For maintenance of the EMST, our KDS improves the previous KDS by Rahmati and Zarei by a near-linear factor in the number of events.

Kinetic Euclidean minimum spanning tree in the plane

This paper presents a kinetic data structure (KDS) for maintenance of the Euclidean minimum spanning tree (EMST) on a set of moving points in 2-dimensional space. For a set of n points moving in the plane we build a KDS of size O(n) in O(nlogn) preprocessing time by which the EMST is maintained efficiently during the motion. This is done by applying the required changes to the combinatorial structure of the EMST which is changed in discrete timestamps. We assume that the motion of the points, i.e. x and y coordinates of the points, are defined by algebraic functions of constant maximum degree. In terms of the KDS performance parameters, our KDS is responsive, local, and compact. The presented KDS is based on monitoring changes of the Delaunay triangulation of the points and edge-length changes of the edges of the current Delaunay triangulation.

Kinetic data structures for all nearest neighbors and closest pair in the plane

This paper presents a kinetic data structure (KDS) for solutions to the all nearest neighbors problem and the closest pair problem in the plane. For a set P of n moving points where the trajectory of each point is an algebraic function of constant maximum degree s, our kinetic algorithm uses O(n) space and O(n log n) preprocessing time, and processes O(n²β²_2s+2(n)log n) events with total processing time O(n²β²_2s+2(n)log² n), where β_s(n) is an extremely slow-growing function. In terms of the KDS performance criteria, our KDS is efficient, responsive (in an amortized sense), and compact. Our deterministic kinetic algorithm for the all nearest neighbors problem improves by an O(log² n) factor the previous randomized kinetic algorithm by Agarwal, Kaplan, and Sharir. The improvement is obtained by using a new sparse graph representation, the Pie Delaunay graph, to reduce the problem to one-dimensional range searching, as opposed to using two-dimensional range searching as in the previous work.

Kinetic pie delaunay graph and its applications

We construct a new proximity graph, called the Pie Delaunay graph, on a set of n points which is a super graph of Yaograph and Euclidean minimum spanning tree (EMST). We efficiently maintain the PieDelaunaygraph where the points are moving in the plane. We use the kinetic PieDelaunaygraph to create a kinetic data structure (KDS) for maintenance of the Yaograph and the EMST on a set of n moving points in 2-dimensional space. Assuming x and y coordinates of the points are defined by algebraic functions of at most degree s, the structure uses O(n) space, O(nlogn) preprocessing time, and processes O(n2λ2s+2(n)βs+2(n)) events for the Yaograph and O(n2λ2s+2(n)) events for the EMST, each in O(log2n) time. Here, λs(n)=nβs(n) is the maximum length of Davenport-Schinzel sequences of order s on n symbols. Our KDS processes nearly cubic events for the EMST which improves the previous bound O(n4) by Rahmati etal. [1].

Kinetic and stationary point-set embeddability for plane graphs

We investigate a kinetic version of point-set embeddability. Given a plane graph G(V,E) where |V|=n, and a set P of n moving points where the trajectory of each point is an algebraic function of constant maximum degree s, we maintain a point-set embedding of G on P with at most three bends per edge during the motion. This requires reassigning the mapping of vertices to points from time to time. Our kinetic algorithm uses linear size, O(nlogn) preprocessing time, and processes O(n2β2s+2(n)logn) events, each in O(log2n) time. Here, βs(n)=λs(n)/ n is an extremely slow-growing function and λs(n) is the maximum length of Davenport-Schinzel sequences of order s on n symbols.

Approximating the minimum closest pair distance and nearest neighbor distances of linearly moving points

Given a set of n moving points in R d , where each point moves along a linear trajectory at arbitrary but constant velocity, we present an O ź ( n 5 / 3 ) -time algorithm1 to compute a ( 1 + ź ) -factor approximation to the minimum closest pair distance over time, for any constant ź 0 and any constant dimension d. This addresses an open problem posed by Gupta, Janardan, and Smid 1.More generally, we consider a data structure version of the problem: for any linearly moving query point q, we want a ( 1 + ź ) -factor approximation to the minimum nearest neighbor distance to q over time. We present a data structure that requires O ź ( n 5 / 3 ) space and O ź ( n 2 / 3 ) query time, O ź ( n 5 ) space and polylogarithmic query time, or O ź ( n ) space and O ź ( n 4 / 5 ) query time, for any constant ź 0 and any constant dimension d. 1The notation O ź is used to hide polylogarithmic factors. That is, O ź ( f ( n ) ) = O ( f ( n ) log c ź n ) , where c is a constant.

Kinetic k-Semi-Yao graph and its applications

This paper introduces a new proximity graph, called the

Kinetic Reverse k -Nearest Neighbor Problem

k

(Reverse) k -nearest neighbors for moving objects

-Semi-Yao graph (

Kinetic euclidean minimum spanning tree in the plane

k