Results 1  10
of
17
Orthogonal Range Searching on the RAM, Revisited
, 2011
"... We present a number of new results on one of the most extensively studied topics in computational geometry, orthogonal range searching. All our results are in the standard word RAM model: 1. We present two data structures for 2d orthogonal range emptiness. The first achieves O(n lg lg n) space and ..."
Abstract

Cited by 37 (7 self)
 Add to MetaCart
(Show Context)
We present a number of new results on one of the most extensively studied topics in computational geometry, orthogonal range searching. All our results are in the standard word RAM model: 1. We present two data structures for 2d orthogonal range emptiness. The first achieves O(n lg lg n) space and O(lg lg n) query time, assuming that the n given points are in rank space. This improves the previous results by Alstrup, Brodal, and Rauhe (FOCS’00), with O(n lg ε n) space and O(lg lg n) query time, or with O(n lg lg n) space and O(lg 2 lg n) query time. Our second data structure uses O(n) space and answers queries in O(lg ε n) time. The best previous O(n)space data structure, due to Nekrich (WADS’07), answers queries in O(lg n / lg lg n) time. 2. We give a data structure for 3d orthogonal range reporting with O(n lg 1+ε n) space and O(lg lg n+ k) query time for points in rank space, for any constant ε> 0. This improves the previous results by Afshani (ESA’08), Karpinski and Nekrich (COCOON’09), and Chan (SODA’11), with O(n lg 3 n) space and O(lg lg n + k) query time, or with O(n lg 1+ε n) space and O(lg 2 lg n + k) query time. Consequently, we obtain improved upper bounds for orthogonal range reporting in all constant dimensions above 3.
Selfimproving algorithms
 in SODA ’06: Proceedings of the seventeenth annual ACMSIAM symposium on Discrete algorithm
"... We investigate ways in which an algorithm can improve its expected performance by finetuning itself automatically with respect to an arbitrary, unknown input distribution. We give such selfimproving algorithms for sorting and computing Delaunay triangulations. The highlights of this work: (i) an al ..."
Abstract

Cited by 33 (6 self)
 Add to MetaCart
(Show Context)
We investigate ways in which an algorithm can improve its expected performance by finetuning itself automatically with respect to an arbitrary, unknown input distribution. We give such selfimproving algorithms for sorting and computing Delaunay triangulations. The highlights of this work: (i) an algorithm to sort a list of numbers with optimal expected limiting complexity; and (ii) an algorithm to compute the Delaunay triangulation of a set of points with optimal expected limiting complexity. In both cases, the algorithm begins with a training phase during which it adjusts itself to the input distribution, followed by a stationary regime in which the algorithm settles to its optimized incarnation. 1
Convex Hull of Points Lying on Lines in o(n log n) Time after Preprocessing
, 2011
"... Motivated by the desire to cope with data imprecision [31], we study methods for taking advantage of preliminary information about point sets in order to speed up the computation of certain structures associated with them. In particular, we study the following problem: given a set L of n lines in th ..."
Abstract

Cited by 4 (3 self)
 Add to MetaCart
(Show Context)
Motivated by the desire to cope with data imprecision [31], we study methods for taking advantage of preliminary information about point sets in order to speed up the computation of certain structures associated with them. In particular, we study the following problem: given a set L of n lines in the plane, we wish to preprocess L such that later, upon receiving a set P of n points, each of which lies on a distinct line of L, we can construct the convex hull of P efficiently. We show that in quadratic time and space it is possible to construct a data structure on L that enables us to compute the convex hull of any such point set P in O(nα(n) log ∗ n) expected time. If we further assume that the points are “oblivious ” with respect to the data structure, the running time improves to O(nα(n)). The same result holds when L is a set of line segments (in general position). We present several extensions, including a tradeoff between space and query time and an outputsensitive algorithm. We also study the “dual problem ” where we show how to efficiently compute the ( ≤ k)level of n lines in the plane, each of which is incident to a distinct point (given in advance). We complement our results by Ω(n log n) lower bounds under the algebraic computation tree model for several related problems, including sorting a set of points (according to, say, their xorder), each of which lies on a given line known in advance. Therefore, the convex hull problem under our setting is easier than sorting, contrary to the “standard ” convex hull and sorting problems, in which the two problems require Θ(n log n) steps in the worst case (under the algebraic computation tree model).
Efficient Quicksort and 2D Convex Hull for CUDA, and MSIMD as a Realistic Model of Massively Parallel Computations
"... Abstract. In recent years CUDA has become a major architecture for multithreaded computations. Unfortunately, its potential is not yet being commonly utilized because many fundamental problems have no practical solutions for such machines. Our goal is to establish a hybrid multicore/parallel theor ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
Abstract. In recent years CUDA has become a major architecture for multithreaded computations. Unfortunately, its potential is not yet being commonly utilized because many fundamental problems have no practical solutions for such machines. Our goal is to establish a hybrid multicore/parallel theoretical model that represents well architectures like NVIDIA CUDA, Intel Larabee, and OpenCL as well as admits easy reuse of the theory of parallel and multicore algorithms whenever applicable. We call our model MSIMD, from multipleSIMD. We apply our model to design Quicksort for MSIMD, and an output sensitive MSIMD 2D Convex Hull algorithm based on [Wenger, 1997], [Bhattacharya and Sen, 1997], and [Kirkpatrick and Seidel, 1986]. Our implementation of the Convex Hull algorithm on CUDA exercises this approach in practice and proves its appropriateness.
Selfimproving Algorithms for Convex Hulls
, 2009
"... We give an algorithm for computing planar convex hulls in the selfimproving model: given a sequence I1, I2,... of planar npoint sets, the upper convex hull conv(I) of each set I is desired. We assume that there exists a probability distribution D on npoint sets, such that the inputs Ij are drawn ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
(Show Context)
We give an algorithm for computing planar convex hulls in the selfimproving model: given a sequence I1, I2,... of planar npoint sets, the upper convex hull conv(I) of each set I is desired. We assume that there exists a probability distribution D on npoint sets, such that the inputs Ij are drawn independently according to D. Furthermore, D is such that the individual points are distributed independently of each other. In other words, the i’th point is distributed according to Di. The Di’s can be arbitrary but are independent of each other. The distribution D is not known to the algorithm in advance. After a learning phase of nε rounds, the expected time to compute conv(I) is O(n + H(conv(I))). Here, H(conv(I)) is the entropy of the output, which is a lower bound for the expected running time of any algebraic computation tree that computes the convex hull. (More precisely, H(conv(I)) is the minimum entropy of any random variable that maps I to a description of conv(I) and to a labeling scheme that proves nonextremality for every point in I not on the hull.) Our algorithm is thus asymptotically optimal for D. 1
Finding Maximum Degrees in Hidden Bipartite Graphs
, 2010
"... An (edge) hidden graph is a graph whose edges are not explicitly given. Detecting the presence of an edge requires expensive edgeprobing queries. We consider thek most connected vertex problem on hidden bipartite graphs. Specifically, given a bipartite graph G with independent vertex sets B and W, t ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
(Show Context)
An (edge) hidden graph is a graph whose edges are not explicitly given. Detecting the presence of an edge requires expensive edgeprobing queries. We consider thek most connected vertex problem on hidden bipartite graphs. Specifically, given a bipartite graph G with independent vertex sets B and W, the goal is to find the k vertices in B with the largest degrees using the minimum number of queries. This problem can be regarded as a topk extension of a semijoin, and is encountered in many applications in practice (e.g., topk spatial join with arbitrarily complex join predicates). If B and W have n and m vertices respectively, the number of queries needed to solve the problem isnm in the worst case. This, however, is a pessimistic estimate on how many queries are necessary on practical data. In fact, on some easy inputs, the problem can be efficiently settled with onlykm+n edges, which is significantly
Beyond Worstcase Analysis for Joins with Minesweeper
, 2014
"... We describe a new algorithm, Minesweeper, that is able to satisfy stronger runtime guarantees than previous join algorithms (colloquially, ‘beyond worstcase guarantees’) for data in indexed search trees. Our first contribution is developing a framework to measure this stronger notion of complexity, ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
(Show Context)
We describe a new algorithm, Minesweeper, that is able to satisfy stronger runtime guarantees than previous join algorithms (colloquially, ‘beyond worstcase guarantees’) for data in indexed search trees. Our first contribution is developing a framework to measure this stronger notion of complexity, which we call certificate complexity, that extends notions of Barbay et al. and Demaine et al.; a certificate is a set of propositional formulae that certifies that the output is correct. This notion captures a natural class of join algorithms. In addition, the certificate allows us to define a strictly stronger notion of runtime complexity than traditional worstcase guarantees. Our second contribution is to develop a dichotomy theorem for the certificatebased notion of complexity. Roughly, we show that Minesweeper evaluates βacyclic queries in time linear in the certificate plus the output size, while for any βcyclic query there is some instance that takes superlinear time in the certificate (and for which the output is no larger than the certificate size). We also extend our certificatecomplexity analysis to queries with bounded treewidth and the triangle query. We present empirical results that certificates can be much smaller than the input size, which suggests that ideas in minesweeper might lead to faster algorithms in practice.
Selfimproving Algorithms for Coordinatewise Maxima [Extended Abstract]
"... Computing the coordinatewise maxima of a planar point set is a classic and wellstudied problem in computational geometry. We give an algorithm for this problem in the selfimproving setting. We have n (unknown) independent distributions D1, D2,..., Dn of planar points. An input pointset (p1, p2,... ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
Computing the coordinatewise maxima of a planar point set is a classic and wellstudied problem in computational geometry. We give an algorithm for this problem in the selfimproving setting. We have n (unknown) independent distributions D1, D2,..., Dn of planar points. An input pointset (p1, p2,..., pn) is generated by taking an independent sample pi from each Di, so the input distribution D is the product i Di. A selfimproving algorithm repeatedly gets input sets from the distribution D (which is a priori unknown) and tries to optimize its running time for D. Our algorithm uses the first few inputs to learn salient features of the distribution, and then becomes an optimal algorithm for distribution D. Let OPTD denote the expected depth of an optimal linear comparison tree computing the maxima for distribution D. Our algorithm eventually has an expected running time of O(OPTD + n), even though it did not know D to begin with. Our result requires new tools to understand linear comparison trees for computing maxima. We show how to convert general linear comparison trees to very restricted versions, which can then be related to the running time of our algorithm. An interesting feature of our algorithm is an interleaved search, where the algorithm tries to determine the likeliest point to be maximal with minimal computation. This allows the running time to be truly optimal for the distribution D.
Fast Computation of OutputSensitive Maxima in a Word RAM
, 2013
"... In this paper, we study the problem of computing the maxima of a set of n points in three dimensions with integer coordinates and show that in a word RAM, the maxima can be found in O n log logn/h n deterministic time in which h is the output size. For h = n1−α this is O(n log(1/α)). This improves t ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
In this paper, we study the problem of computing the maxima of a set of n points in three dimensions with integer coordinates and show that in a word RAM, the maxima can be found in O n log logn/h n deterministic time in which h is the output size. For h = n1−α this is O(n log(1/α)). This improves the previous O(n log log h) time algorithm and can be considered surprising since it gives a linear time algorithm when α> 0 is a constant, which is faster than the current best deterministic and randomized integer sorting algorithms. We observe that improving this running time is most likely difficult since it requires breaking a number of important barriers, even if randomization is allowed. Additionally, we show that the same deterministic running time could be achieved for performing n point location queries in an arrangement of size h. Finally, our maxima result can be extended to higher dimensions by paying a logn/h n factor penalty per dimension. This has further interesting consequences for example it preserves the linear running time when h ≤ n1−α, for a constant α> 0, and thus it shows that for a variety of input distributions the maxima can be computed in linear expected time without knowing the distribution. 1