[Paper Review] Geometric Algorithms with Limited Workspace: A Survey

Bahareh Banyassady, Matias Korman+1 more|arXiv (Cornell University)|Jun 15, 2018

Computational Geometry and Mesh Generation51 references3 citations

TL;DR

This survey presents a comprehensive overview of geometric algorithms under the limited workspace model, where input is read-only and only a small, sublinear workspace is available. It details techniques like the compressed stack framework and time-space trade-offs, achieving near-optimal performance for problems such as visibility region computation and common tangent detection with constant or sublinear space.

ABSTRACT

In the limited workspace model, we consider algorithms whose input resides in read-only memory and that use only a constant or sublinear amount of writable memory to accomplish their task. We survey recent results in computational geometry that fall into this model and that strive to achieve the lowest possible running time. In addition to discussing the state of the art, we give some illustrative examples and mention open problems for further research.

Motivation & Objective

• To provide a unified overview of recent advances in geometric algorithms under the limited workspace model, where only a small amount of writable memory is available.
• To identify and analyze core algorithmic techniques—such as the compressed stack framework—that enable efficient computation with minimal workspace.
• To explore time-space trade-offs for fundamental geometric problems, including visibility regions, convex hulls, and common tangents.
• To highlight open problems and research directions in designing efficient algorithms for memory-constrained devices like sensors, drones, and smartphones.
• To bridge theoretical insights from computational complexity and streaming models with practical geometric algorithm design under space constraints.

Proposed method

• The paper surveys algorithms that operate with a workspace of size $ s = O(1) $ to $ s = o(n) $, using only read-only input and a small amount of writable memory.
• It introduces the compressed stack framework, which explicitly stores only a subset of a stack and recomputes missing parts on demand, enabling time-space trade-offs for stack-based algorithms.
• For problems like $k$-visibility region computation, the paper uses time-space trade-offs based on $k$-selection algorithms, achieving $ Oig{(}(k+c)n/s + n/log sig{)} $ time with $ s $ workspace cells.
• The method for computing common tangents uses a simple yet subtle loop-based approach that runs in $ O(n) $ time with $ O(1) $ workspace, relying on geometric properties of disjoint convex hulls.
• The framework is extended to handle edge-to-edge visibility and minimum-link paths in simple polygons, using constant workspace and $ O(nm) $ time for output size $ m $.
• Randomized algorithms are also considered, allowing unlimited random bits but requiring them to be stored in workspace if revisited.

Experimental results

Research questions

• RQ1 What is the smallest workspace size $ s $ for which the visibility region of a point in a polygon can be computed in linear time?
• RQ2 Can the compressed stack framework be generalized to other data structures such as queues, deques, or trees?
• RQ3 Is it possible to compute outer common tangents of two non-disjoint polygons in $ O(n) $ time using only $ O(1) $ workspace cells?
• RQ4 How can time-space trade-offs be optimized for $k$-visibility region computation, especially for intermediate values of $ s $ between $ \log n $ and $ n $?
• RQ5 What are the fundamental limits of deterministic and randomized algorithms in the limited workspace model for classic geometric problems?

Key findings

• The compressed stack framework enables a time-space trade-off: for a stack-based algorithm running in $ O(n) $ time, the new algorithm runs in $ O(n^2 \log n / 2^s) $ time for $ s = o(\log n) $, and in $ O(n^{1+1/\log s}) $ time for $ s \geq \log n $.
• For $ k $-visibility region computation, a time-space trade-off of $ O\big{(}(k+c)n/s + n\log s\big{)} $ is achieved using $ s $ workspace cells, where $ c $ is the number of critical vertices.
• Common tangents of two disjoint polygons with $ n $ vertices can be computed in $ O(n) $ time and $ O(1) $ workspace, using a simple loop-based algorithm with subtle geometric analysis.
• The weak visibility region of an edge in a simple polygon can be computed in $ O(nm) $ time using constant workspace, where $ m $ is the output size.
• A minimum-link path between two points in a simple polygon can be computed in $ O(n^2) $ time with constant workspace, based on edge-to-edge visibility algorithms.
• For $ s = n^\varepsilon $ with any fixed $ \varepsilon > 0 $, the visibility region can be computed in $ O(n) $ time, showing that linear time is achievable with sublinear workspace.