10 research outputs found
An Optimal Algorithm for the Separating Common Tangents of two Polygons
We describe an algorithm for computing the separating common tangents of two
simple polygons using linear time and only constant workspace. A tangent of a
polygon is a line touching the polygon such that all of the polygon lies to the
same side of the line. A separating common tangent of two polygons is a tangent
of both polygons where the polygons are lying on different sides of the
tangent. Each polygon is given as a read-only array of its corners. If a
separating common tangent does not exist, the algorithm reports that.
Otherwise, two corners defining a separating common tangent are returned. The
algorithm is simple and implies an optimal algorithm for deciding if the convex
hulls of two polygons are disjoint or not. This was not known to be possible in
linear time and constant workspace prior to this paper.
An outer common tangent is a tangent of both polygons where the polygons are
on the same side of the tangent. In the case where the convex hulls of the
polygons are disjoint, we give an algorithm for computing the outer common
tangents in linear time using constant workspace.Comment: 12 pages, 6 figures. A preliminary version of this paper appeared at
SoCG 201
Memory-Constrained Algorithms for Simple Polygons
A constant-workspace algorithm has read-only access to an input array and may
use only O(1) additional words of bits, where is the size of
the input. We assume that a simple -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 time. We also consider preprocessing a simple polygon for
shortest path queries when the space constraint is relaxed to allow words
of working space. After a preprocessing of time, we are able to solve
shortest path queries between any two points inside the polygon in
time.Comment: Preprint appeared in EuroCG 201
Computing a visibility polygon using few variables
We present several algorithms for computing the visibility polygon of a
simple polygon from a viewpoint inside the polygon, when the polygon
resides in read-only memory and only few working variables can be used. The
first algorithm uses a constant number of variables, and outputs the vertices
of the visibility polygon in O(n\Rout) time, where \Rout denotes the number
of reflex vertices of that are part of the output. The next two algorithms
use O(\log \Rin) variables, and output the visibility polygon in O(n\log
\Rin) randomized expected time or O(n\log^2 \Rin) deterministic time, where
\Rin is the number of reflex vertices of .Comment: 11 pages. Full version of paper in Proceedings of ISAAC 201
Space-Time Trade-offs for Stack-Based Algorithms
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 variables, we can
modify it so that it runs in time using a workspace of O(s)
variables (for any ) or time using variables (for any ). 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
Computing the visibility polygon using few variables
We present several algorithms for computing the visibility polygon of a simple polygon from a viewpoint inside the polygon, when the polygon resides in read-only memory and only few working variables can be used. The first algorithm uses a constant number of variables, and outputs the vertices of the visibility polygon in time, where denotes the number of reflex vertices of that are part of the output. The next two algorithms use O(logr) variables, and output the visibility polygon in O(nlogr) randomized expected time or O(nlog 2 r) deterministic time, where r is the number of reflex vertices of .© 2011 Springer-Verlag.SCOPUS: cp.kinfo:eu-repo/semantics/publishe