242 research outputs found

    Space-Time Trade-offs for Stack-Based Algorithms

    Get PDF
    In memory-constrained algorithms we have read-only access to the input, and the number of additional variables is limited. In this paper we introduce the compressed stack technique, a method that allows to transform algorithms whose space bottleneck is a stack into memory-constrained algorithms. Given an algorithm \alg\ that runs in O(n) time using Θ(n)\Theta(n) variables, we can modify it so that it runs in O(n2/s)O(n^2/s) time using a workspace of O(s) variables (for any so(logn)s\in o(\log n)) or O(nlogn/logp)O(n\log n/\log p) time using O(plogn/logp)O(p\log n/\log p) variables (for any 2pn2\leq p\leq n). We also show how the technique can be applied to solve various geometric problems, namely computing the convex hull of a simple polygon, a triangulation of a monotone polygon, the shortest path between two points inside a monotone polygon, 1-dimensional pyramid approximation of a 1-dimensional vector, and the visibility profile of a point inside a simple polygon. Our approach exceeds or matches the best-known results for these problems in constant-workspace models (when they exist), and gives the first trade-off between the size of the workspace and running time. To the best of our knowledge, this is the first general framework for obtaining memory-constrained algorithms

    Memory-Constrained Algorithms for Simple Polygons

    Get PDF
    A constant-workspace algorithm has read-only access to an input array and may use only O(1) additional words of O(logn)O(\log n) bits, where nn is the size of the input. We assume that a simple nn-gon is given by the ordered sequence of its vertices. We show that we can find a triangulation of a plane straight-line graph in O(n2)O(n^2) time. We also consider preprocessing a simple polygon for shortest path queries when the space constraint is relaxed to allow ss words of working space. After a preprocessing of O(n2)O(n^2) time, we are able to solve shortest path queries between any two points inside the polygon in O(n2/s)O(n^2/s) time.Comment: Preprint appeared in EuroCG 201

    Efficient Geometric Algorithms in the EREW-PRAM

    Get PDF

    A Contribution to Triangulation Algorithms for Simple Polygons

    Get PDF
    Decomposing simple polygon into simpler components is one of the basic tasks in computational geometry and its applications. The most important simple polygon decomposition is triangulation. The known algorithms for polygon triangulation can be classified into three groups: algorithms based on diagonal inserting, algorithms based on Delaunay triangulation, and the algorithms using Steiner points. The paper briefly explains the most popular algorithms from each group and summarizes the common features of the groups. After that four algorithms based on diagonals insertion are tested: a recursive diagonal inserting algorithm, an ear cutting algorithm, Kong’s Graham scan algorithm, and Seidel’s randomized incremental algorithm. An analysis concerning speed, the quality of the output triangles and the ability to handle holes is done at the end

    Computational Geometry Column 42

    Get PDF
    A compendium of thirty previously published open problems in computational geometry is presented.Comment: 7 pages; 72 reference
    corecore