Results 1 
7 of
7
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 17 (3 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.
Towards InPlace Geometric Algorithms and Data Structures
 In Proceedings of the Twentieth ACM Symposium on Computational Geometry
, 2003
"... For many geometric problems, there are ecient algorithms that surprisingly use very little extra space other than the given array holding the input. For many geometric query problems, there are ecient data structures that need no extra space at all other than an array holding a permutation of the ..."
Abstract

Cited by 17 (4 self)
 Add to MetaCart
For many geometric problems, there are ecient algorithms that surprisingly use very little extra space other than the given array holding the input. For many geometric query problems, there are ecient data structures that need no extra space at all other than an array holding a permutation of the input. In this paper, we obtain the rst such spaceeconomical solutions for a number of fundamental problems, including threedimensional convex hulls, twodimensional Delaunay triangulations, xeddimensional range queries, and xeddimensional nearest neighbor queries.
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.
unknown title
"... Spaceefficient algorithms for computing the convex hull of a simple polygonal line in linear time 1,2,3 ..."
Abstract
 Add to MetaCart
(Show Context)
Spaceefficient algorithms for computing the convex hull of a simple polygonal line in linear time 1,2,3
Spaceefficient Algorithms for Empty Space Recognition among a Point Set in 2D and 3D
, 2011
"... In this paper, we consider the problem of designing inplace algorithms for computing the maximum area empty rectangle of arbitrary orientation among a set of points in 2D, and the maximum volume empty axisparallel cuboid among a set of points in 3D. If n points are given in an array of size n, the ..."
Abstract
 Add to MetaCart
In this paper, we consider the problem of designing inplace algorithms for computing the maximum area empty rectangle of arbitrary orientation among a set of points in 2D, and the maximum volume empty axisparallel cuboid among a set of points in 3D. If n points are given in an array of size n, the worst case time complexity of our proposed algorithms for both the problems is O(n³); both the algorithms use O(1) extra space in addition to the array containing the input points.
An InPlace MinMax Priority Search Tree
"... One of the classic data structures for storing point sets in R² is the priority search tree, introduced by McCreight in 1985. We show that this data structure can be made inplace, i.e., it can be stored in an array such that each entry stores only one point of the point set and no entry is stored i ..."
Abstract
 Add to MetaCart
One of the classic data structures for storing point sets in R² is the priority search tree, introduced by McCreight in 1985. We show that this data structure can be made inplace, i.e., it can be stored in an array such that each entry stores only one point of the point set and no entry is stored in more than one location of that array. It combines a binary search tree with a heap. We show that all the standard query operations can be answered within the same time bounds as for the original priority search tree, while using only O(1) extra space. We introduce the minmax priority search tree which is a combination of a binary search tree and a minmax heap. We show that all the standard queries which can be done in two separate versions of a priority search tree can be done with a single minmax priority search tree. As an application, we present an inplace algorithm to enumerate all maximal empty axisparallel rectangles amongst points in a rectangular region R in R² in O(m log n) time with O(1) extraspace, where m is the total number of maximal empty rectangles.
Inplace Algorithm for Priority Search Tree and its use in Computing Largest Empty AxisParallel Rectangle
"... Abstract. There is a high demand of spaceefficient algorithms in builtin or embedded softwares. In this paper, we consider the problem of designing spaceefficient algorithms for computing the maximum area empty rectangle (MER) among a set of points inside a rectangular region R in 2D. We first p ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract. There is a high demand of spaceefficient algorithms in builtin or embedded softwares. In this paper, we consider the problem of designing spaceefficient algorithms for computing the maximum area empty rectangle (MER) among a set of points inside a rectangular region R in 2D. We first propose an inplace algorithm for computing the priority search tree with a set of n points in R using O(logn) extra bit space in O(n logn) time. It supports all the standard queries on priority search tree in O(log2 n) time. We also show an application of this algorithm in computing the largest empty axisparallel rectangle. Our proposed algorithm needs O(n log2 n+m) time and O(logn) workspace apart from the array used for storing n input points. Here m is the number of maximal empty rectangles present in R. Finally, we consider the problem of locating the maximum area empty rectangle of arbitrary orientation among a set of n points, and propose an O(n3 logn) time inplace algorithm for that problem. 1