154,137 research outputs found
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
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
Comparative Evaluation of Packet Classification Algorithms for Implementation on Resource Constrained Systems
This paper provides a comparative evaluation of a number of known classification algorithms that have been considered for both software and hardware implementation. Differently from other sources, the comparison has been carried out on implementations based on the same principles and design choices. Performance measurements are obtained by feeding the implemented classifiers with various traffic traces in the same test scenario. The comparison also takes into account implementation feasibility of the considered algorithms in resource constrained systems (e.g. embedded processors on special purpose network platforms). In particular, the comparison focuses on achieving a good compromise between performance, memory usage, flexibility and code portability to different target platforms
Memory-constrained pathfinding algorithms for partially-known environments
Pathfinding is the search for a goal state given a start state, within either static or dynamic environments. Many pathfinding algorithms exist, including established algorithms such as A*, SMA*, and D*. These algorithms all provide optimal solution paths, using all available memory. Consequently, Algorithms such as A* and D* are known to be inefficient in terms of memory space usage. SMA* and similar algorithms provide a means by which optimal solution paths can be found while being memory efficient. SMA* and such algorithms are restricted to static environments, in which state traversal costs never change. This is a severe limitation, as one of the primary fields for search algorithms are games, many of which involve dynamic environments. Presented in this paper is a dynamic variant of the established D* Lite algorithm, that is able to provide an optimal solution path, if given sufficient memory, while using as little memory as possible. It is also the case that in some areas, an optimal solution is not needed. This may be the case for robotics. Many algorithms already exist in this area, such as Anytime algorithms for time-limited searches. Real-Time algorithms for when the agent needs to move while planning its path. Also presented is an algorithm for real-time planning when an agent does not have a priori knowledge of the environment, and also limited memory capacity. This algorithm sacrifices optimality, but in turn is highly memory efficient, even in comparison to other algorithms designed for memory efficiency
- âŠ