With the proliferation of wireless communications and the rapid advances in technologies for tracking the positions of continuously moving objects, algorithms for efficiently answering queries about large numbers of moving objects increasingly are needed. One such query is the reverse nearest neighbor (RNN) query that returns the objects that have a query object as their closest object. While algorithms have been proposed that compute RNN queries for non-moving objects, there have been no proposals for answering RNN queries for continuously moving objects. Another such query is the nearest neighbor (NN) query, which has been studied extensively and in many contexts. Like the RNN query, the NN query has not been explored for moving query and data points. This paper proposes an algorithm for answering RNN queries for continuously moving points in the plane. As a part of the solution to this problem and as a separate contribution, an algorithm for answering NN queries for continuously moving points is also proposed. The results of performance experiments are reported.

Inherent in the operation of many decision support and continuous referral systems is the notion of the "influence" of a data point on the database. This notion arises in examples such as finding the set of customers affected by the opening of a new store outlet location, notifying the subset of subscribers to a digital library who will find a newly added document most relevant, etc. Standard approaches to determining the influence set of a data point involve range searching and nearest neighbor queries. In this paper, we formalize a novel notion of influence based on reverse neighbor queries and its variants. Since the nearest neighbor relation is not symmetric, the set of points that are closest to a query point (i.e., the nearest neighbors) differs from the set of points that have the query point as their nearest neighbor (called the reverse nearest neighbors). Influence sets based on reverse nearest neighbor (RNN) queries seem to capture the intuitive notion of influence from our ...

Given a set S of n sites (points), and a distance measure d, the nearest neighbor searching problem is to build a data structure so that given a query point q, the site nearest to q can be found quickly. This paper gives a data structure for this problem; the data structure is built using the distance function as a “black box”. The structure is able to speed up nearest neighbor searching in a variety of settings, for example: points in low-dimensional or structured Euclidean space, strings under Hamming and edit distance, and bit vector data from an OCR application. The data structures are observed to need linear space, with a modest constant factor. The preprocessing time needed per site is observed to match the query time. The data structure can be viewed as an application of a “kd-tree ” approach in the metric space setting, using Voronoi regions of a subset in place of axis-aligned boxes. 1

Given a set S of n points in R d , and a graph G having the points of S as its vertices, the stretch factor t of G is dened as the maximal value jpqj G =jpqj, where p; q 2 S, p 6= q, jpqj G is the length of a shortest path in G between p and q, and jpqj is the Euclidean distance between p and q. We consider the problem of designing algorithms that, for an arbitrary constant > 0, compute an -approximation to this stretch factor, i.e., a value t such that t t (1 + )t. We give eÆcient solutions for the cases when G is a path, cycle, or tree. The main idea used in all the algorithms is to use well-separated pair decompositions to speed up the computations. 1 Introduction Let S be a set of n points in R d , where d 1 is a small constant, and let G be an undirected connected graph having the points of S as its vertices. The length of any edge (p; q) of G is dened as the Euclidean distance jpqj between the two vertices p and q. The length of a path in G is dened a...

In this paper we propose an algorithm for answering reverse nearest neighbor (RNN) queries, a problem formulated only recently. This class of queries is strongly related to that of nearest neighbor (NN) queries, although the two are not necessarily complementary. Unlike nearest neighbor queries, RNN queries find the set of database points that have the query point as the nearest neighbor. There is no other proposal we are aware of, that provides an algorithmic approach to answer RNN queries. The earlier approach for RNN queries ([KM99]) is based on the pre-computation of neighborhood information that is organized in terms of auxiliary data structures. It can be argued that the precomputation of the RNN information for all points in the database can be too restrictive. In the case of dynamic databases, insert and update operations are expensive and can lead to modifications of large parts of the auxiliary data structures. Also, answers to RNN queries for a set of data points depend on t...

Given a set S of n points in the plane, we give an O(n log n)-time algorithm that constructs a plane t-spanner for S, for t 10:02, such that the degree of each point of S is bounded from above by 27, and the total edge length is proportional to the weight of a minimum spanning tree of S. These constants are all worst case constants that are artifacts of our proofs. In practice, we believe them to be much smaller. Previously, no algorithms were known for constructing plane t-spanners of bounded degree.

Abstract. Many computational geometry algorithms involve the construction and maintenance of planar arrangements of conic arcs. Implementing a general, robust arrangement package for conic arcs handles most practical cases of planar arrangements covered in literature. A possible approach for implementing robust geometric algorithms is to use exact algebraic number types — yet this may lead to a very slow, inefficient program. In this paper we suggest a simple technique for filtering the computations involved in the arrangement construction: when constructing an arrangement vertex, we keep track of the steps that lead to its construction and the equations we need to solve to obtain its coordinates. This construction history can be used for answering predicates very efficiently, compared to a naïve implementation with an exact number type. Furthermore, using this representation most arrangement vertices may be computed approximately at first and can be refined later on in cases of ambiguity. Since such cases are relatively rare, the resulting implementation is both efficient and robust. 1

Basic proximity problems for low-dimensional point sets, such as closest pair (CP) and approximate nearest neighbor (ANN), have been studied extensively in the computational geometry literature, with well over a hundred papers published (we merely cite the survey by Smid [10] and omit most references). Generally, optimal algorithms designed for worst-case input require hierarchical spatial structures with sophisticated balancing conditions (we mention, for example, the BBD trees of Arya et al., balanced quadtrees, and Callahan and Kosaraju's fair-split trees); dynamization of these structures is even more involved (relying on Sleator and Tarjan's dynamic trees or Frederickson's topology trees). In this note, we point out that much simpler algorithms with the same performance are possible using standard, though nonalgebraic, RAM operations. This is interesting, considering that nonalgebraic operations have been used before in the literature (e.g., in the original version of the BBD tree [2], as well as in various randomized CP methods). The CP algorithm can be stated completely in one paragraph. Assume coordinates are positive integers bounded by U = 2 w. Given a point p in a constant dimension d where the i-th coordinate p i is the number p iw p i0 in binary, dene its shue (p) to be the number p 1w pdw p 10 p d0 in binary, and dene shifts i (p) = (p 1 + bi2

Given a set of moving points in IR , we show how to cluster them in advance, using a small number of clusters, so that at any time this static clustering is competitive with the optimal k-center clustering at that time. The advantage of this approach is that it avoids updating the clustering as time passes. We also show how to maintain this static clustering eciently under insertions and deletions.

Abstract not found