Output-Sensitive Algorithms for Uniform Partitions of Points
16 Dec 1999-pp 403-414
TL;DR: A deterministic algorithm that achieves a running time of O(b4Δ2 log n + n) and a Monte-Carlo algorithm that runs in sub-quadratic time for certain values of b and Δ are presented.
Abstract: We consider the following one- and two-dimensional bucketing problems: Given a set S of n points in R1 or R2 and a positive integer b, distribute the points of S into b equal-size buckets so that the maximum number of points in a bucket is minimized. Suppose at most (n/b) + Δ points lies in each bucket in an optimal solution. We present algorithms whose time complexities depend on b and Δ. No prior knowledge of Δ is necessary for our algorithms.
For the one-dimensional problem, we give a deterministic algorithm that achieves a running time of O(b4Δ2 log n + n). For the two-dimensional problem, we present a Monte-Carlo algorithm that runs in sub-quadratic time for certain values of b and Δ. The previous algorithms, by Asano and Tokuyama [1], searched the entire parameterized space and required Ω(n2) time in the worst case even for constant values of b and Δ.
Citations
More filters
01 Jan 2001
TL;DR: This chapter reviews randomization algorithms developed in the last few years to solve a wide range of geometric optimization problems, including facility location, proximity problems, nearest neighbor searching, statistical estimators, and Euclidean TSP.
Abstract: This chapter reviews randomization algorithms developed in the last few years to solve a wide range of geometric optimization problems. We review a number of general techniques, including randomized binary search, randomized linear-programming algorithms, and random sampling. Next, we describe several applications of these techniques, including facility location, proximity problems, nearest neighbor searching, statistical estimators, and Euclidean TSP. Work by the rst author was supported by Army Research O ce MURI grant DAAH04-96-1-0013, by a Sloan fellowship, by NSF grants EIA{9870724, EIA{997287, and CCR{9732787, and by a grant from the U.S.-Israeli Binational Science Foundation. Center for Geometric Computing, Department of Computer Science, Box 90129, Duke University, Durham, NC 27708-0129, USA. E-mail: pankaj@cs.duke.edu Department of Computer Science and Engineering, IIT Delhi, New Delhi 110016, India. Email:ssen@cse.iitd.ernet.in
26 citations
01 May 2003
TL;DR: In solving the problem of translating an infinite grid so that the number of k-occupied cells is maximized or minimized, a data structure T is designed that maintains in O(log n) time per operation, a function f: R →R under the following query and update operations.
Abstract: We consider the problem of translating a (finite or infinite) square grid G over a set S of n points in the plane in order to maximize some objective function. We say that a grid cell is k-occupied if it contains k or more points of S. The main set of problems we study have to do with translating an infinite grid so that the number of k-occupied cells is maximized or minimized. For these problems we obtain running times of the form O(kn polylog (n)). We also consider the problem of translating a finite size grid, with m cells, in order to maximize the number of k-occupied cells. Here we obtain a running time of the form O(knm polylog (nm)). In solving these problems, we design a data structure T that maintains in O(log n) time per operation, a function f: R →R under the following query and update operations where [a, b) is a continuous interval inR: 1. INSERT(T, a, b, δ): Increase the value of f(x) by δ for all x ∈ [a, b). 2. DELETE(T, a, b, δ): Decrease the value of f(x) by δ for all x ∈ [a, b). 3. MAX-COVER(): Return max{f(x): x ∈R}. 4. MAX-COVER-WITNESS(): Return a value x* such that f(x*) = max{f(x): x ∈R}. 5. MAX-IN(a, b): Returns max{f(x): x ∈ [a, b)}. 6. MAX-WITNESS-IN(a, b): Returns a value x* such that f(x*) = max{f(x): x ∈ [a, b)}. as well as the min counter-parts of these queries.
13 citations
Cites background from "Output-Sensitive Algorithms for Uni..."
...Several other researchers have considered grid placement problems in which rotations and resizing of the grid cells can take place [1, 2]....
[...]
08 Aug 2001
TL;DR: This work considers the problem of placing a regular grid over a set of points in order to minimize (or maximize) the number of grid cells not containing any points and gives an O(n log n) time and O( n) space algorithm for this problem.
Abstract: We consider the problem of placing a regular grid over a set of points in order to minimize (or maximize) the number of grid cells not containing any points. We give an O(n log n) time and O(n) space algorithm for this problem. As part of this algorithm we develop a new data structure for solving a problem on intervals that is interesting in its own right and may have other applications.
9 citations
Cites background from "Output-Sensitive Algorithms for Uni..."
...[1] the problem was to minimize the maximum number of points in a given cell....
[...]
Posted Content•
TL;DR: In this article, the authors show that a recently proposed password authentication scheme based on geometric hashing has several security weaknesses, and that the use of this scheme should be avoided in practice.
Abstract: We show that a recently proposed password authentication scheme based on geometric hashing has several security weaknesses, and that the use of this scheme should be avoided in practice.
References
More filters
Book•
01 Jan 1987TL;DR: This book offers a modern approach to computational geo- metry, an area thatstudies the computational complexity of geometric problems with an important role in this study.
Abstract: This book offers a modern approach to computational geo- metry, an area thatstudies the computational complexity of geometric problems. Combinatorial investigations play an important role in this study.
2,284 citations
01 Jun 1991
TL;DR: A theorem on partitioning point sets inEd (d fixed) is proved and an efficient construction of partition trees based on it is given, which yields a simplex range searching structure with linear space, O(n logn) deterministic preprocessing time, andO(n1?1/d(logn)O(1)) query time.
Abstract: We prove a theorem on partitioning point sets inEd (d fixed) and give an efficient construction of partition trees based on it. This yields a simplex range searching structure with linear space,O(n logn) deterministic preprocessing time, andO(n1?1/d(logn)O(1)) query time. WithO(nlogn) preprocessing time, where ? is an arbitrary positive constant, a more complicated data structure yields query timeO(n1?1/d(log logn)O(1)). This attains the lower bounds due to Chazelle [C1] up to polylogarithmic factors, improving and simplifying previous results of Chazelleet al. [CSW].
The partition result implies that, forrd≤n1??, a (1/r)-approximation of sizeO(rd) with respect to simplices for ann-point set inEd can be computed inO(n logr) deterministic time. A (1/r)-cutting of sizeO(rd) for a collection ofn hyperplanes inEd can be computed inO(n logr) deterministic time, provided thatr≤n1/(2d?1).
404 citations
"Output-Sensitive Algorithms for Uni..." refers background in this paper
...We also need the following result by Matousek on simplex range searching. Lemma 8 (Matousek [ 6 ])....
[...]
TL;DR: This is the first considerable improvement on this bound after its early solution approximately 27 years ago and applies to improve the current bounds on the combinatorial complexities of k -levels in the arrangement of line segments, convex polygons in the union of n lines, parametric minimum spanning trees, and parametric matroids in general.
Abstract: We prove an O(n(k+1)1/3) upper bound for planar k -sets. This is the first considerable improvement on this bound after its early solution approximately 27 years ago. Our proof technique also applies to improve the current bounds on the combinatorial complexities of k -levels in the arrangement of line segments, k convex polygons in the union of n lines, parametric minimum spanning trees, and parametric matroids in general. 26 June, 1998 Editors-in-Chief: la href=../edboard.html#chiefslJacob E. Goodman, Richard Pollackl/al 19n3p373.pdf yes no no yes
277 citations
01 Jan 1993
TL;DR: In this paper, a simple Steiner triangulation of a simple polygon with the property that a ray can intersect at most O(log n) triangles before reaching the polygon boundary is presented.
Abstract: We propose a very simple ray-shooting algorithm, whose only data structure is a triangulation. The query algorithm, after locating the triangle containing the origin of the ray, walks along the ray, advancing from one triangle to a neighboring one until the polygon boundary is reached. The key result of the paper is a Steiner triangulation of a simple polygon with the property that a ray can intersect at most O(log n) triangles before reaching the polygon boundary. We are able to compute such a triangulation in linear sequential time, or in O(log n) parallel time using O(n/log n) processors. This gives a simple, yet optimal, ray-shooting algorithm for a simple polygon. Using a well-known technique, we can extend our triangulation procedure to a multiconnected polygon with k components and n vertices, so that a ray intersects at most O(√κ log n) triangles. © 1995 Academic Press, Inc.
167 citations
01 May 1995
TL;DR: A Steiner triangulation of a simple polygon with the property that a ray can intersect at most O(log n) triangles before reaching the polygon boundary is presented.
Abstract: We propose a very simple ray-shooting algorithm, whose only data structure is a triangulation. The query algorithm, after locating the triangle containing the origin of the ray, walks along the ray, advancing from one triangle to a neighboring one until the polygon boundary is reached. The key result of the paper is a Steiner triangulation of a simple polygon with the property that a ray can intersect at most O(log n) triangles before reaching the polygon boundary. We are able to compute such a triangulation in linear sequential time, or in O(log n) parallel time using O(n/log n) processors. This gives a simple, yet optimal, ray-shooting algorithm for a simple polygon. Using a well-known technique, we can extend our triangulation procedure to a multiconnected polygon with k components and n vertices, so that a ray intersects at most O(?k log n) triangles.
151 citations