Read-only Array Research Articles

Common Tangents of Two Disjoint Polygons in Linear Time and Constant Workspace

We provide a remarkably simple algorithm to compute all (at most four) common tangents of two disjoint simple polygons. Given each polygon as a read-only array of its corners in cyclic order, the algorithm runs in linear time and constant workspace and is the first to achieve the two complexity bounds simultaneously. The set of common tangents provides basic information about the convex hulls of the polygons—whether they are nested, overlapping, or disjoint—and our algorithm thus also decides this relationship.

Linear time algorithm to cover and hit a set of line segments optimally by two axis-parallel squares

This paper discusses the problem of covering and hitting a set of line segments L in R2 by a pair of axis-parallel congruent squares of minimum size. We also discuss the restricted version of covering, where each line segment in L is to be covered completely by at least one square. The proposed algorithms assume that the input segments are given in a read-only array. For each of these problems (i.e. covering, hitting and restricted covering problems), our proposed algorithm reports the optimum result by executing only two passes of reading the input array sequentially. All these algorithms need only O(1) extra space. The solution of these problems also give a 2 approximation for covering and hitting those line segments L by two congruent disks of minimum radius with same computational complexity.

A Time-Space Trade-off for the Shortest Path Tree in a Simple Polygon

A [Formula: see text]-workspace algorithm may use a workspace of [Formula: see text] words which can be read and written, in addition to their input, which is provided as a read-only array of [Formula: see text] items. We present a [Formula: see text]-workspace algorithm for constructing the shortest path tree of a simple polygon [Formula: see text] with [Formula: see text] vertices, with respect to a given point inside the polygon in [Formula: see text] time, where [Formula: see text] is the time for computing the visibility polygon of a given point inside a simple polygon with [Formula: see text] additional words of space.

A new algorithmic framework for basic problems on binary images

This paper presents a new algorithmic framework for some basic problems on binary images. Algorithms for binary images such as one of extracting a connected component containing a query pixel and that of connected components labeling play basic roles in image processing. Those algorithms usually use linear work space for efficient implementation. In this paper we propose algorithms for several basic problems on binary images which are efficient in time and space, using space-efficient algorithms for grid graphs. More exactly, some of them run in O(nlogn) time using O(1) work space and the others run in O(n) or O(nlogn) time using O(n) work space for a binary image of n pixels stored in a read-only array.

Space-efficient algorithm for computing a centerpoint of a set of points in [formula omitted

We study a space-efficient algorithm for computing a centerpoint for a set P of n points in R2, where the points in P are given in a read-only array. We propose an algorithm that finds a centerpoint of P in O(T(n2)log3⁡n) time using O(S(n2)) extra space, where T(n) and S(n) are the time and extra space complexities of computing the median among a set of n elements stored in a read-only array. We also present the applications of this algorithm for computing the Tukey depth and k-hull of a point set in R2.

Algorithmic analysis of array-accessing programs

For programs whose data variables range over Boolean or finite domains, program verification is decidable, and this forms the basis of recent tools for software model checking. In this article, we consider algorithmic verification of programs that use Boolean variables, and in addition, access a single read-only array whose length is potentially unbounded, and whose elements range over an unbounded data domain. We show that the reachability problem, while undecidable in general, is (1) Pspace-complete for programs in which the array-accessing for-loops are not nested, (2) decidable for a restricted class of programs with doubly nested loops. The second result establishes connections to automata and logics defining languages over data words.

Constant-work-space algorithms for geometric problems

Constant-work-space algorithms may use only constantly many cells of storage in addition to their input, which is provided as a read-only array. We show how to construct several geometric structures efficiently in the constant-work-space model. Traditional algorithms process the input into a suitable data structure (like a doubly-connected edge list) that allows efficient traversal of the structure at hand. In the constant-work-space setting, however, we cannot afford to do this. Instead, we provide operations that compute the desired features on the fly by accessing the input with no extra space. The whole geometric structure can be obtained by using these operations to enumerate all the features. Of course, we must pay for the space savings by slower running times. While the standard data structure allows us to implement traversal operations in constant time, our schemes typically take linear time to read the input data in each step. We begin with two simple problems: triangulating a planar point set and finding the trapezoidal decomposition of a simple polygon. In both cases adjacent features can be enumerated in linear time per step, resulting in total quadratic running time to output the whole structure. Actually, we show that the former result carries over to the Delaunay triangulation, and hence the Voronoi diagram. This also means that we can compute the largest empty circle of a planar point set in quadratic time and constant work-space. As another application, we demonstrate how to enumerate the features of an Euclidean minimum spanning tree (EMST) in quadratic time per step, so that the whole EMST can be found in cubic time using constant work-space. Finally, we describe how to compute a shortest geodesic path between two points in a simple polygon. Although the shortest path problem in general graphs is NL-complete (Jakoby and Tantau 2003), this constrained problem can be solved in quadratic time using only constant work-space.

Constant-Work-Space Algorithms for Shortest Paths in Trees and Simple Polygons

Constant-work-space algorithms model computation when space is at a premium: the input is given as a read-only array that allows random access to its entries, and the algorithm may use constantly many additional registers of O(logn) bits each, where n denotes the input size. We present such algorithms for two restricted variants of the shortest path problem. First, we describe how to report a simple path between two arbitrary nodes in a given tree. Using a technique called \computing instead of storing, we obtain a naive algorithm that needs quadratic time and a constant number of additional registers. We then show how to improve the running time to linear by applying a technique named \simulated parallelization. Second, we show how to compute a shortest geodesic path between two points in a simple polygon in quadratic time and with constant work-space.