Showing papers in "Algorithmica in 1993"

Orienting polygonal parts without sensors

Abstract: In manufacturing it is often necessary to orient parts prior to packing or assembly. We say that a planar part ispolygonal if its convex hull is a polygon. We consider the following problem: given a list ofn vertices describing a polygonal part whose initial orientation is unknown, find the shortest sequence of mechanical gripper actions that is guaranteed to orient the part up to symmetry in its convex hull. We show that such a sequence exists for any polygonal part by giving anO[n 2 logn) algorithm for finding the sequence. Since the gripper actions do not require feedback, this result implies that any polygonal part can be orientedwithout sensors.

Algorithms for parallel memory, I: Two-level memories

Abstract: We provide the first optimal algorithms in terms of the number of input/outputs (I/Os) required between internal memory and multiple secondary storage devices for the problems of sorting, FFT, matrix transposition, standard matrix multiplication, and related problems. Our two-level memory model is new and gives a realistic treatment of {\em parallel block transfer}, in which dureing a single I/O each of the $P$ secondary storage devices can simultaneously transfer a contiguous block of $B$ records. The model pertains to a large-scale uniprocessor system or parallel multiprocessor system with $P$ disks. In addition, the sorting, FFT, permutation network, and standard matrixmultiplication algorithms are typically optimal in terms of the amount of internal processing time. The difficulty in developing optimal algorithms is to cope with the partitioning of memory into $P$ separate physical devices. Our algorithms'' performance can be significantly better than those obtained by the well-known but nonoptimal technique of disk striping. Our optimal sorting algorithm is randomized, but practical; the probability of using more than $\ell$ times the optimal number of I/Os is exponentially small in $\ell$ (log $\ell$)log($M/B$), where $M$ is the internal memory size.

An 11/6-approximation algorithm for the network steiner problem

Abstract: An instance of the Network Steiner Problem consists of an undirected graph with edge lengths and a subset of vertices; the goal is to find a minimum cost Steiner tree of the given subset (i.e., minimum cost subset of edges which spans it). An 11/6-approximation algorithm for this problem is given. The approximate Steiner tree can be computed in the time0(¦V¦ ¦E¦ + ¦S¦4), whereV is the vertex set,E is the edge set of the graph, andS is the given subset of vertices.

Nonholonomic multibody mobile robots: Controllability and motion planning in the presence of obstacles

Abstract: We consider mobile robots made of a single body (car-like robots) or several bodies (tractors towing several trailers sequentially hooked). These robots are known to be nonholonomic, i.e., they are subject to nonintegrable equality kinematic constraints involving the velocity. In other words, the number of controls (dimension of the admissible velocity space), is smaller than the dimension of the configuration space. In addition, the range of possible controls is usually further constrained by inequality constraints due to mechanical stops in the steering mechanism of the tractor. We first analyze the controllability of such nonholonomic multibody robots. We show that the well-known Controllability Rank Condition Theorem is applicable to these robots even when there are inequality constraints on the velocity, in addition to the equality constraints. This allows us to subsume and generalize several controllability results recently published in the Robotics literature concerning nonholonomic mobile robots, and to infer several new important results. We then describe an implemented planner inspired by these results. We give experimental results obtained with this planner that illustrate the theoretical results previously developed.

Issues in computing contact forces for non-penetrating rigid bodies

Abstract: In rigid-body simulation it is necessary to compute the forces that arise between contacting bodies to prevent interpenetration. This paper studies the problem of rigid-body simulation when the bodies being simulated are restricted to contact at only finitely many points. Some theoretical and practical issues in computing contact forces for systems with large numbers of contact points are considered. Both systems of rigid bodies with and without Coulomb friction are studied. Complexity results are derived for certain classes of configurations and numerical methods for computing contact forces are discussed.

The Uniform Memory Hierarchy Model of Computation

Abstract: TheUniform Memory Hierarchy (UMH) model introduced in this paper captures performance-relevant aspects of the hierarchical nature of computer memory. It is used to quantify architectural requirements of several algorithms and to ratify the faster speeds achieved by tuned implementations that use improved data-movement strategies.

Computing the intersection-depth of polyhedra

Abstract: Given two intersecting polyhedraP, Q and a directiond, find the smallest translation ofQ alongd that renders the interiors ofP andQ disjoint. The same problem can also be posed without specifying the direction, in which case the minimum translation over all directions is sought. These are fundamental problems that arise in robotics and computer vision. We develop techniques for implicitly building and searching convolutions and apply them to derive efficient algorithms for these problems.

Schedulers for larger classes of pinwheel instances

Abstract: The pinwheel is a hard-real-time scheduling problem for scheduling satellite ground stations to service a number of satellites without data loss. Given a multiset of positive integers (instance)A={a1,..., an}, the problem is to find an infinite sequence (schedule) of symbols from {1,2,...,n} such that there is at least one symboli within any interval of ai symbols (slots). Not all instancesA can be scheduled; for example, no “successful” schedule exists for instances whose density,ρ(A)=∑ (l/ai), is larger than 1. It has been shown that all instances whose densities are less than a 0.5 density threshold can always be scheduled. If a schedule exists, another concern is the design of a fast on-line scheduler (FOLS) which can generate each symbol of the schedule in constant time. Based on the idea of “integer reduction,” two new FOLSs which can schedule different classes of pinwheel instances, are proposed in this paper. One uses “single-integer reduction” and the other uses “double-integer” reduction. They both improve the previous 0.5 result and have density thresholds of 13/20 and2/3, respectively. In particular, if the elements inA are large, the density thresholds will asymptotically approach In 2 and 1/R2, respectively.

The slab dividing approach to solve the euclidean p-center problem

Abstract: Givenn demand points on the plane, the EuclideanP-Center problem is to findP supply points, such that the longest distance between each demand point and its closest supply point is minimized. The time complexity of the most efficient algorithm, up to now, isO(n 2 p−1· logn). In this paper, we present an algorithm with time complexityO(n 0(√P)).

Analytic variations on quadtrees

Abstract: Quadtrees constitute a hierarchical data structure which permits fast access to multidimensional data. This paper presents the analysis of the expected cost of various types of searches in quadtrees -- fully specified and partial-match queries. The data model assumes random points with independently drawn coordinate values. The analysis leads to a class of "full-history" divide-and-conquer recurrences. These recurrences are solved using generating functions, either exactly for dimensiond=2, or asymptotically for higher dimensions. The exact solutions involve hypergeometric functions. The general asymptotic solutions rely on the classification of singularities of linear differential equations with analytic coefficients, and on singularity analysis techniques. These methods are applicable to the asymptotic solution of a wide range of linear recurrences, as may occur in particular in the analysis of multidimensional searching problems.

An opportunistic global path planner

Abstract: In this paper we describe a robot path-planning algorithm that constructs a global skeleton of free-space by incremental local methods. The curves of the skeleton are the loci of maxima of an artificial potential field that is directly proportional to distance of the robot from obstacles. Our method has the advantage of fast convergence of local methods in uncluttered environments, but it also has a deterministic and efficient method of escaping local extremal points of the potential function. We first describe a general roadmap algorithm, for configuration spaces of any dimension, and then describe specific applications of the algorithm for robots with two and three degrees of freedom.

Constructing strongly convex approximate hulls with inaccurate primitives

Abstract: The first half of this paper introducesEpsilon Geometry, a framework for the development of robust geometric algorithms using inaccurate primitives. Epsilon Geometry is based on a very general model of imprecise computations, which includes floating-point and rounded-integer arithmetic as special cases. The second half of the paper introduces the notion of a (−ɛ)-convex polygon, a polygon that remains convex even if its vertices are all arbitrarily displaced by a distance ofɛ of less, and proves some interesting properties of such polygons. In particular, we prove that for every point set there exists a (−ɛ)-convex polygonH such that every point is at most 4ɛ away fromH. Using the tools of Epsilon Geometry, we develop robust algorithms for testing whether a polygon is (−ɛ)-convex, for testing whether a point is inside a (−ɛ)-convex polygon, and for computing a (−ɛ)-convex approximate hull for a set of points.

An efficient algorithm for finding the CSG representation of a simple polygon

Abstract: Modeling two-dimensional and three-dimensional objects is an important theme in computer graphics. Two main types of models are used in both cases: boundary representations, which represent the surface of an object explicitly but represent its interior only implicitly, and constructive solid geometry representations, which model a complex object, surface and interior together, as a boolean combination of simpler objects. Because neither representation is good for all applications, conversion between the two is often necessary. We consider the problem of converting boundary representations of polyhedral objects into constructive solid geometry (CSG) representations. The CSG representations for a polyhedronP are based on the half-spaces supporting the faces ofP. For certain kinds of polyhedra this problem is equivalent to the corresponding problem for simple polygons in the plane. We give a new proof that the interior of each simple polygon can be represented by a monotone boolean formula based on the half-planes supporting the sides of the polygon and using each such half-plane only once. Our main contribution is an efficient and practicalO(n logn) algorithm for doing this boundary-to-CSG conversion for a simple polygon ofn sides. We also prove that such nice formulae do not always exist for general polyhedra in three dimensions.

Approximate string matching with suffix automata

Abstract: Theapproximate string matching problem is, given a text string, a pattern string, and an integerk, to find in the text all approximate occurrences of the pattern. An approximate occurrence means a substring of the text with edit distance at mostk from the pattern. We give a newO(kn) algorithm for this problem, wheren is the length of the text. The algorithm is based on the suffix automaton with failure transitions and on the diagonalwise monotonicity of the edit distance table. Some experiments showing that the algorithm has a small overhead are reported.

The searching over separators strategy to solve some NP-hard problems in subexponential time

Abstract: In this paper we propose a new strategy for designing algorithms, called the searching over separators strategy. Suppose that we have a problem where the divide-and-conquer strategy can not be applied directly. Yet, also suppose that in an optimal solution to this problem, there exists a separator which divides the input points into two parts,A d andC d, in such a way that after solving these two subproblems withA d andC d as inputs, respectively, we can merge the respective subsolutions into an optimal solution. Let us further assume that this problem is an optimization problem. In this case our searching over separators strategy will use a separator generator to generate all possible separators. For each separator, the problem is solved by the divide-and-conquer strategy. If the separator generator is guaranteed to generate the desired separator existing in an optimal solution, our searching over separators strategy will always produce an optimal solution. The performance of our approach will critically depend upon the performance of the separator generator. It will perform well if the total number of separators generated is relatively small. We apply this approach to solve the discrete EuclideanP-median problem (DEPM), the discrete EuclideanP-center problem (DEPC), the EuclideanP-center problem (EPC), and the Euclidean traveling salesperson problem (ETSP). We propose $$O(n^{o(\sqrt P )} )$$ algorithms for the DEPM problem, the DEPC problem, and the EPC problem, and we propose an $$O(n^{o(\sqrt n )} )$$ algorithm for the ETSP problem, wheren is the number of input points.

Tiling a Polygon with Parallelograms

Abstract: Given a simple polygon in the plane we devise a quadratic algorithm for determining the existence of, and constructing, a tiling of the polygon with parallelograms. We also show that any two parallelogram tilings can be obtained from one another by a sequence of “rotations,” and give a condition for the uniqueness of such a tiling. Three generalizations of this problem, that of tiling by a fixed set of triangles, a fixed set of trapezoids, or parallelogram tiling for polygonal regions with holes, are shown to be NP-complete.

Selecting distances in the plane

Abstract: We present a randomized algorithm for computing the kth smallest distance in a set ofn points in the plane, based on the parametric search technique of Megiddo [Mel]. The expected running time of our algorithm is O(n4/3 log8/3 n). The algorithm can also be made deterministic, using a more complicated technique, with only a slight increase in its running time. A much simpler deterministic version of our procedure runs in time O(n3/2 log5/2 n). All versions improve the previously best-known upper bound ofO(@#@ n9/5 log4/5 n) by Chazelle [Ch]. A simpleO(n logn)-time algorithm for computing an approximation of the median distance is also presented.

Ray shooting on triangles in 3-space

Abstract: We present a uniform approach to problems involving lines in 3-space. This approach is based on mapping lines inR3 into points and hyperplanes in five-dimensional projective space (Plucker space). We obtain new results on the following problems: 1. Preprocessn triangles so as to answer efficiently the query: “Given a ray, which is the first triangle hit?” (Ray- shooting problem). We discuss the ray-shooting problem for both disjoint and nondisjoint triangles. 2. Construct the intersection of two nonconvex polyhedra in an output sensitive way with asubquadratic overhead term. 3. Construct the arrangement ofn intersecting triangles in 3-space in an output-sensitive way, with asubquadratic overhead term. 4. Efficiently detect the first face hit by any ray in a set of axis-oriented polyhedra. 5. Preprocessn lines (segments) so as to answer efficiently the query “Given two lines, is it possible to move one into the other without crossing any of the initial lines (segments)?” (Isotopy problem). If the movement is possible produce an explicit representation of it.

Fast linear expected-time algorithms for computing maxima and convex hulls

Abstract: This paper examines the expected complexity of boundary problems on a set ofN points inK-space. We assume that the points are chosen from a probability distribution in which each component of a point is chosen independently of all other components. We present an algorithm to find the maximal points usingKN + O (N1−1/K log1/K N) expected scalar comparisons, for fixedK≥ 2. A lower bound shows that the algorithm is optimal in the leading term. We describe a simple maxima algorithm that is easy to code, and present experimental evidence that it has similar running time. For fixedK ≥ 2, an algorithm computes the convex hull of the set in 2KN + O(N1−1/K log1/KN) expected scalar comparisons. The history of the algorithms exhibits interesting interactions among consulting, algorithm design, data analysis, and mathematical analysis of algorithms.

Mechanical parts orienting: The case of a polyhedron on a table

Abstract: The positioning and orienting of parts is a standard problem in manufacturing. Orienting parts is often a prelude to the assembly of parts at tight tolerances. This paper considers the problem of orienting a part resting on a table, by tilting the table. The initial orientation of the part is assumed to be completely unknown. The objective is to tilt the table in a manner that reduces the uncertainty in the part's orientation. This paper focuses on three-dimensional polyhedral parts, with infinite friction between the parts and the table, and for which all transitions between different face-table contacts may be regarded as rotations across edges. The paper proposes a planner that determines a sequence of tilting operations designed to minimize the uncertainty in the part's orientation. The planner runs in timeO(n3), wheren is the number of faces of the polyhedron. The planner produces a sequence ofO(n) distinct tilting operations. Each tilting operation wobbles the table until the part is in steady state.

Planning a time-minimal motion among moving obstacles

Abstract: Motion planning for a point robot is studied in a time-varying environment. Each obstacle is a convex polygon that moves in a fixed direction at a constant speed. The point to be reached (referred to as the destination point) also moves along a known trajectory. The concept of “accessibility” from a point to a moving object is introduced, and is used to define a graph on a set of moving obstacles. If the point robot is able to move faster than any of the obstacles, then the graph exhibits an important property: a time-minimal motion is given as a sequence of edges in the graph. An algorithm is described for generating a time-minimal motion and its execution time is analyzed.

Packings in two dimensions: Asymptotic average-case analysis of algorithms

Abstract: New approximation algorithms for packing rectangles into a semi-infinite strip are introduced in this paper. Within a standard probability model, an asymptotic average-case analysis is given for the wasted space in the packings produced by these algorithms.

A semidynamic construction of higher-order voronoi diagrams and its randomized analysis

Abstract: Thek-Delaunay tree extends the Delaunay tree introduced in [1], and [2]. It is a hierarchical data structure that allows the semidynamic construction of the higher-order Voronoi diagrams of a finite set ofn points in any dimension. In this paper we prove that a randomized construction of thek-Delaunay tree, and thus of all the order≤k Voronoi diagrams, can be done inO(n logn+k 3n) expected time and O(k2n) expected storage in the plane, which is asymptotically optimal for fixedk. Our algorithm extends tod-dimensional space with expected time complexityO(k ⌈(d+1)/2⌉+1 n ⌊(d+1)/2⌋) and space complexityO(k ⌈(d+1)/2⌉ n ⌊(d+1)/2⌋). The algorithm is simple and experimental results are given.

Clocked adversaries for hashing

Abstract: A “clocked adversary” is a program that can time its operations and base its behavior on the results of those timings. While it is well known that hashing performs poorly in the worst case, recent results have proven that, for reference-string programs, the probability of falling into a bad case can be driven arbitrarily low. We show that this is not true for clocked adversaries. This emphasizes the limits on the appiicability of theorems on the behavior of hashing schemes on reference string programs, and raises a novel set of problems dealing with optimality of and vulnerability to clocked adversaries.

Randomization for robot tasks: Using dynamic programming in the space of knowledge states

Abstract: This paper explores the use of randomization as a primitive action in the solution of robot tasks. An example of randomization is the strategy of shaking a bin containing a part in order to orient the part in a desired stable state with some high probability. Further examples include tapping, vibrating, twirling, and random search. For instance, it is sometimes beneficial for a system to execute random motions purposefully when the precise motions required to perform an operation are unknown, as when they lie below the available sensor resolution. The purpose of this paper is to provide a theoretical framework for the planning and execution of randomized strategies for robot tasks. This framework is built on the standard backchaining approach of dynamic programming. Specifically, a randomizing planner backchains from the goal in a state space whose states describe the knowledge available to the system at run-time. By choosing random actions in a principled manner at run-time, a system can sometimes obtain a probabilistic strategy for accomplishing a task even when no guaranteed strategy exists for accomplishing that task. In other cases, the system may be able to obtain a speedup over an existing guaranteed strategy. The main result of this paper consists of two examples. One example shows that randomization can sometimes speed up task completion from exponential time to polynomial time. The other example shows that such a speedup is not always possible.

Constructing the Voronoi diagram of a set of line segments in parallel

Abstract: In this paper we give a parallel algorithm for constructing the Voronoi diagram of a polygonal scene, i.e., a set of line segments in the plane such that no two segments intersect except possibly at their endpoints. Our algorithm runs inO(log2n) time usingO(n) processors in the CREW PRAM model.

Floorplanning by graph dualization: L-shaped modules

Abstract: We propose a novel technique for constructing a floorplan from an adjacency requirement -- represented by a graphG. The algorithm finds a geometric dual ofG involving both rectangular and L-shaped modules. This is the first dualization technique which permits L-shaped modules. We can test inO(n3/2) time ifG admits an L-shaped dual and construct one, if it exists, inO(n2) time, wheren is the number of modules.

A Long-step barrier method for convex quadratic programming

Abstract: In this paper we propose a long-step logarithmic barrier function method for convex quadratic programming with linear equality constraints. After a reduction of the barrier parameter, a series of long steps along projected Newton directions are taken until the iterate is in the vicinity of the center associated with the current value of the barrier parameter. We prove that the total number of iterations isO(źnL) orO(nL), depending on how the barrier parameter is updated.

Weaving patterns of lines and line segments in space

Abstract: Aweaving W is a simple arrangement of lines (or line segments) in the plane together with a binary relation specifying which line is “above” the other. A system of lines (or line segments) in 3-space is called arealization ofW, if its projection into the plane isW and the “above-below” relations between the lines respect the specifications. Two weavings are equivalent if the underlying arrangements of lines are combinatorially equivalent and the “above-below” relations are the same. An equivalence class of weavings is said to be aweaving pattern. A weaving pattern isrealizable if at least one element of the equivalence class has a three-dimensional realization. A weaving (pattern)W is calledperfect if, along each line (line segment) ofW, the lines intersecting it are alternately “above” and “below.” We prove that (i) a perfect weaving pattern ofn lines is realizable if and only ifn ≤ 3, (ii) a perfect m byn weaving pattern of line segments (in a grid-like fashion) is realizable if and only if min(m, n) ≤ 3, (iii) ifn is sufficiently large, then almost all weaving patterns ofn lines are nonrealizable.

Sublinear merging and natural mergesort

Abstract: The complexity of merging two sorted sequences into one is linear in the worst case as well as in the average case. There are, however, instances for which a sublinear number of comparisons is sufficient. We consider the problem of measuring and exploiting such instance easiness. The merging algorithm presented, Adaptmerge, is shown to adapt optimally to different kinds of measures of instance easiness. In the sorting problem the concept of instance easiness has received a lot of attention, and it is interpreted by a measure of presortedness. We apply Adaptmerge in the already adaptive sorting algorithm Natural Mergesort. The resulting algorithm, Adaptive Mergesort, optimally adapts to several, known and new, measures of presortedness. We also prove some interesting results concerning the relation between measures of presortedness proposed in the literature.