We address the problem of replicating a Voronoi diagram @math of a planar point set @math by making proximity queries, which are of three possible (in decreasing order of information content): 1. the exact location of the nearest site(s) in @math ; 2. the distance to and label(s) of the nearest site(s) in @math ; 3. a unique label for every nearest site in @math . We provide algorithms showing how queries of Type 1 and Type 2 allow an exact cloning of @math with @math queries and @math processing time. We also prove that queries of Type 3 can never exactly clone @math , but we show that with @math queries we can construct an @math -approximate cloning of @math . In addition to showing the limits of nearest-neighbor database security, our methods also provide one of the first natural algorithmic applications of retroactive data structures.
Motivated by the problem of having a robot discover the shape of an object by touching it @cite_22 , there is considerable amount of related work in the computational geometry literature on discovering polygonal and polyhedral shapes from probing (e.g., see @cite_9 @cite_29 @cite_43 @cite_1 @cite_12 @cite_3 @cite_4 @cite_26 @cite_41 @cite_34 ). Rather than review all of this work in detail, we (e.g., see @cite_9 @cite_29 @cite_1 @cite_12 @cite_3 @cite_4 @cite_41 @cite_34 ). We refer the interested reader to the survey and book chapter by Skiena @cite_18 @cite_13 , and simply mention that, with the notable exception of work by Dobkin @cite_12 , this prior work is primarily directed at discovering obstacles in a two-dimensional environment using various kinds of contact probes. Thus, although it is related, most of this prior work cannot be adapted to the problem of discovering a Voronoi diagram through nearest-neighbor probes.
@cite_18 @cite_26 @cite_4 @cite_22 @cite_41 @cite_9 @cite_29 @cite_1 @cite_3 @cite_43 @cite_34 @cite_13 @cite_12
2015816463 1502916507 1970845672 1980745281
We present algorithms to reconstruct the planar cross-section of a simply connected object from data points measured by rays. The rays are semi-infinite curves representing, for example, the laser beam or the articulated arms of a robot moving around the object. This paper shows that the information provided by the rays is crucial (though generally neglected) when solving 2-dimensional reconstruction problems. The main property of the rays is that they induce a total order on the measured points. This order is shown to be computable in optimal time O(n log n). The algorithm is fully dynamic and allows the insertion or the deletion of a point in O(log n) time. From this order a polygonal approximation of the object can be deduced in a straightforward manner. However, if insufficient data are available or if the points belong to several connected objects, this polygonal approximation may not be a simple polygon or may intersect the rays. This can be checked in O(n log n) time. The order induced by the rays can also be used to find a strategy for discovering the exact shape of a simple (but not necessarily convex) polygon by means of a minimal number of probes. When each probe outcome consists of a contact point, a ray measuring that point and the normal to the object at the point, we have shown that 3n-3 probes are necessary and sufficient if the object has n non-colinear edges. Each probe can be determined in O(log n) time yielding an O(n log n)-time 0(n)-space algorithm. When each probe outcome consists of a contact point and a ray measuring that point but not the normal, the same strategy can still be applied. Under a mild condition, 8n-4 probes are sufficient to discover a shape that is almost surely the actual shape of the object. The nearestor near-neighbor query problems arise in a large variety of database applications, usually in the context of similarity searching. Of late, there has been increasing interest in building search index structures for performing similarity search over high-dimensional data, e.g., image databases, document collections, time-series databases, and genome databases. Unfortunately, all known techniques for solving this problem fall prey to the of dimensionality." That is, the data structures scale poorly with data dimensionality; in fact, if the number of dimensions exceeds 10 to 20, searching in k-d trees and related structures involves the inspection of a large fraction of the database, thereby doing no better than brute-force linear search. It has been suggested that since the selection of features and the choice of a distance metric in typical applications is rather heuristic, determining an approximate nearest neighbor should su ce for most practical purposes. In this paper, we examine a novel scheme for approximate similarity search based on hashing. The basic idea is to hash the points Supported by NAVY N00014-96-1-1221 grant and NSF Grant IIS-9811904. Supported by Stanford Graduate Fellowship and NSF NYI Award CCR-9357849. Supported by ARO MURI Grant DAAH04-96-1-0007, NSF Grant IIS-9811904, and NSF Young Investigator Award CCR9357849, with matching funds from IBM, Mitsubishi, Schlumberger Foundation, Shell Foundation, and Xerox Corporation. Permission to copy without fee all or part of this material is granted provided that the copies are not made or distributed for direct commercial advantage, the VLDB copyright notice and the title of the publication and its date appear, and notice is given that copying is by permission of the Very Large Data Base Endowment. To copy otherwise, or to republish, requires a fee and or special permission from the Endowment. Proceedings of the 25th VLDB Conference, Edinburgh, Scotland, 1999. from the database so as to ensure that the probability of collision is much higher for objects that are close to each other than for those that are far apart. We provide experimental evidence that our method gives signi cant improvement in running time over other methods for searching in highdimensional spaces based on hierarchical tree decomposition. Experimental results also indicate that our scheme scales well even for a relatively large number of dimensions (more than 50). We consider the exploration of a simple polygon P by a robot that moves from vertex to vertex along edges of the visibility graph of P. The visibility graph has a vertex for every vertex of P and an edge between two vertices if they see each other—that is, if the line segment connecting them lies inside P entirely. While located at a vertex, the robot is capable of ordering the vertices it sees in counterclockwise order as they appear on the boundary, and for every two such vertices, it can distinguish whether the angle between them is convex (l π) or reflex ( > π). Other than that, distant vertices are indistinguishable to the robot. We assume that an upper bound on the number of vertices is known. We obtain the general result that a robot exploring any locally oriented, arc-labeled graph G can always determine the base graph of G. Roughly speaking, this is the smallest graph that cannot be distinguished by a robot from G by its observations alone, no matter how it moves. Combining this result with various other techniques allows the ability to show that a robot exploring a polygon P with the preceding capabilities is always capable of reconstructing the visibility graph of P. We also show that multiple identical, indistinguishable, and deterministic robots of this kind can always solve the weak rendezvous problem in which they need to position themselves such that they mutually see each other—for instance, such that they form a clique in the visibility graph. We consider the problem of localizing a robot in a known environment modeled by a simple polygon P. We assume that the robot has a map of P but is placed at an unknown location inside P. From its initial location, the robot sees a set of points called the visibility polygon V of its location. In general, sensing at a single point will not suffice to uniquely localize the robot, since the set H of points in P with visibility polygon V may have more than one element. Hence, the robot must move around and use range sensing and a compass to determine its position (i.e., localize itself). We seek a strategy that minimizes the distance the robot travels to determine its exact location. We show that the problem of localizing a robot with minimum travel is NP-hard. We then give a polynomial time approximation scheme that causes the robot to travel a distance of at most (k - 1)d, where k = |H|, which is no greater than the number of reflex vertices of P, and d is the length of a minimum length tour that would allow the robot to verify its true initial location by sensing. We also show that this bound is the best possible.