Results 1  10
of
20
SpaceEfficient Algorithms for Computing the Convex Hull of a Simple Polygonal Line in Linear Time
"... We present spaceefficient algorithms for computing the convex hull of a simple polygonal line inplace, in linear time. It turns out that the problem is as hard as stable partition, i.e., if there were a truly simple solution then stable partition would also have a truly simple solution, and vice v ..."
Abstract

Cited by 16 (2 self)
 Add to MetaCart
We present spaceefficient algorithms for computing the convex hull of a simple polygonal line inplace, in linear time. It turns out that the problem is as hard as stable partition, i.e., if there were a truly simple solution then stable partition would also have a truly simple solution, and vice versa. Nevertheless, we present a simple selfcontained solution that uses O(log n) space, and indicate how to improve it to O(1) space with the same techniques used for stable partition. If the points inside the convex hull can be discarded, then there is a truly simple solution that uses a single call to stable partition, and even that call can be spared if only extreme points are desired (and not their order). If the polygonal line is closed, then the problem admits a very simple solution which does not call for stable partitioning at all.
Linesegment intersection made inplace
, 2007
"... We present a spaceefficient algorithm for reporting all k intersections induced by a set of n line segments in the plane. Our algorithm is an inplace variant of Balaban’s algorithm and, in the worst case, runs in O(n log2 n+k) time using O(1) extra words of memory in addition to the space used f ..."
Abstract

Cited by 8 (2 self)
 Add to MetaCart
We present a spaceefficient algorithm for reporting all k intersections induced by a set of n line segments in the plane. Our algorithm is an inplace variant of Balaban’s algorithm and, in the worst case, runs in O(n log2 n+k) time using O(1) extra words of memory in addition to the space used for the input to the algorithm.
Inplace algorithms for computing (layers of) maxima
 In: Proceedings of the 10th Scandinavian Workshop on Algorithm Theory (SWAT ’06
, 2006
"... Abstract. We describe spaceefficient algorithms for solving problems related to finding maxima among points in two and three dimensions. Our algorithms run in optimal O(n log n) time and occupy only constant extra space in addition to the space needed for representing the input. 1 ..."
Abstract

Cited by 6 (1 self)
 Add to MetaCart
Abstract. We describe spaceefficient algorithms for solving problems related to finding maxima among points in two and three dimensions. Our algorithms run in optimal O(n log n) time and occupy only constant extra space in addition to the space needed for representing the input. 1
SpaceEfficient Algorithms for Klee’s Measure Problem
, 2005
"... We give spaceefficient geometric algorithms for three related problems. Given a set of n axisaligned rectangles in the plane, we calculate the area covered by the union of these rectangles (Klee’s measure problem) in O(n 3/2 log n) time with O(√n) extra space. If the input can be destroyed and the ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
We give spaceefficient geometric algorithms for three related problems. Given a set of n axisaligned rectangles in the plane, we calculate the area covered by the union of these rectangles (Klee’s measure problem) in O(n 3/2 log n) time with O(√n) extra space. If the input can be destroyed and there are no degenerate cases and input coordinates are all integers, we can solve Klee’s measure problem in O(n log² n) time with O(log² n) extra space. Given a set of n points in the plane, we find the axisaligned unit square that covers the maximum number of points in O(n log³ n) time with O(log² n) extra space.
Speculative Parallelization of a Randomized Incremental Convex Hull Algorithm
 Proc. Int’l Workshop Computational Geometry and Applications
, 2004
"... Abstract. Finding the fastest algorithm to solve a problem is one of the main issues in Computational Geometry. Focusing only on worst case analysis or asymptotic computations leads to the development of complex data structures or hard to implement algorithms. Randomized algorithms appear in this sc ..."
Abstract

Cited by 5 (4 self)
 Add to MetaCart
Abstract. Finding the fastest algorithm to solve a problem is one of the main issues in Computational Geometry. Focusing only on worst case analysis or asymptotic computations leads to the development of complex data structures or hard to implement algorithms. Randomized algorithms appear in this scenario as a very useful tool in order to obtain easier implementations within a good expected time bound. However, parallel implementations of these algorithms are hard to develop and require an indepth understanding of the language, the compiler and the underlying parallel computer architecture. In this paper we show how we can use speculative parallelization techniques to execute in parallel iterative algorithms such as randomized incremental constructions. In this paper we focus on the convex hull problem, and show that, using our speculative parallelization engine, the sequential algorithm can be automatically executed in parallel, obtaining speedups with as little as four processors, and reaching 5.15x speedup with 28 processors. 1
MemoryConstrained Algorithms for Simple Polygons
, 2011
"... A constantworkspace algorithm has readonly access to an input array and may use only O(1) additional words of O(log n) bits, where n is the size of the input. We show that we can find a triangulation of a plane straightline graph with n vertices in O(n²) time. We also consider preprocessing a sim ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
A constantworkspace algorithm has readonly access to an input array and may use only O(1) additional words of O(log n) bits, where n is the size of the input. We show that we can find a triangulation of a plane straightline graph with n vertices in O(n²) time. We also consider preprocessing a simple ngon, which is given by the ordered sequence of its vertices, for shortest path queries when the space constraint is relaxed to allow s words of working space. After a preprocessing of O(n²) time, we are able to solve shortest path queries between any two points inside the polygon in O(n²/s) time.
InPlace 2d Nearest Neighbor Search
, 2007
"... Abstract We revisit a classic problem in computational geometry: preprocessing a planar npoint set to answer nearest neighbor queries. In SoCG 2004, Br"onnimann, Chan, and Chen showed that it is possible to design an efficient data structure that takes no extra space at all other than the ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
Abstract We revisit a classic problem in computational geometry: preprocessing a planar npoint set to answer nearest neighbor queries. In SoCG 2004, Br&quot;onnimann, Chan, and Chen showed that it is possible to design an efficient data structure that takes no extra space at all other than the input array holding a permutation of the points. The best query time known for such &quot;inplace data structures &quot; is O(log 2 n). In this paper, we break the O(log 2 n) barrier by providing a method that answers nearest neighbor queries in time O((log n) log3=2 2 log log n) = O(log
MultiPass Geometric Algorithms \Lambda
, 2006
"... Abstract We propose the study of exact geometric algorithms that require limited storage and make only a small number of passes over the input. Fundamental problems such as lowdimensional linear programming and convex hulls are considered. 1 Introduction The multipass model. Streaming algorithms t ..."
Abstract
 Add to MetaCart
Abstract We propose the study of exact geometric algorithms that require limited storage and make only a small number of passes over the input. Fundamental problems such as lowdimensional linear programming and convex hulls are considered. 1 Introduction The multipass model. Streaming algorithms that make a single pass over the input and work with a small amount of space have grown in popularity [31], because of the ability of such algorithms to handle massive data sets. Since only one pass over the input is required, data elements may arrive one at a time and the entire data set never needs to be physically stored. Study of geometric algorithms in the datastream model has already begun to take place in several recent papers (e.g., [3, 10, 37]). In this paper, we examine a more powerful multipass model, where algorithms are allowed to make multiple passes over the input. The input remains unchanged after each pass, and depending on the problem, the answer may be sent to a writeonly output stream. The goal is to minimize the amount of working space (measured in words, in this paper), while keeping the number of passes small. As usual, we would like to bound the total running time as well (which includes the cost of scanning and is at least the input size times the number of passes); for this purpose, we assume unitcost random access for the working space (but not the input, of course).
Abstract A SpaceEfficient Algorithm for Segment Intersection
"... We examine the space requirement for the classic linesegment intersection problem. Using socalled implicit data structures, we show how to make the standard sweepline algorithm run in O((n + k) log 2 n) time with only O(log 2 n) extra space, where n is the number of line segments and k is the numb ..."
Abstract
 Add to MetaCart
We examine the space requirement for the classic linesegment intersection problem. Using socalled implicit data structures, we show how to make the standard sweepline algorithm run in O((n + k) log 2 n) time with only O(log 2 n) extra space, where n is the number of line segments and k is the number of intersections. If division is allowed and input can be destroyed, the algorithm can run in O((n + k) log n) time with O(1) extra space. 1
unknown title
"... Slope selection, i.e. selecting the slope with rank k among all � � n 2 lines induced by a collection P of points, results in a widely used robust estimator for linefitting. In this paper, we demonstrate that it is possible to perform slope selection in expected O(n·log2 n) time using only constant ..."
Abstract
 Add to MetaCart
Slope selection, i.e. selecting the slope with rank k among all � � n 2 lines induced by a collection P of points, results in a widely used robust estimator for linefitting. In this paper, we demonstrate that it is possible to perform slope selection in expected O(n·log2 n) time using only constant extra space in addition to the space needed for representing the input. 1