SIAM Digital Library
 
 
 

SIAM J. on Computing

BROWSE VOLUMES

Year Range: 

All Journal content published prior to 1997 is part of LOCUS.

Search Issue | RSS Feeds RSS
Previous Issue

1997

Volume 26, Issue 6, pp. 1559-1803


The Random Adversary: A Lower-Bound Technique for Randomized Parallel Algorithms

Philip D. MacKenzie

SIAM J. Comput. 26, pp. 1559-1580 (22 pages) | Cited 1 time

Online Publication Date: July 28, 2006

Full Text: | Download PDF

Show Abstract
The random-adversary technique is a general method for proving lower bounds on randomized parallel algorithms. The bounds apply to the number of communication steps, and they apply regardless of the processors' instruction sets, the lengths of messages, etc. This paper introduces the random-adversary technique and shows how it can be used to obtain lower bounds on randomized parallel algorithms for load balancing, compaction, padded sorting, and finding Hamiltonian cycles in random graphs. Using the random-adversary technique, we obtain the first lower bounds for randomized parallel algorithms which are provably faster than their deterministic counterparts (specifically, for load balancing and related problems).

Reconfiguring Arrays with Faults Part I: Worst-Case Faults

Richard J. Cole, Bruce M. Maggs, and Ramesh K. Sitaraman

SIAM J. Comput. 26, pp. 1581-1611 (31 pages) | Cited 3 times

Online Publication Date: July 28, 2006

Full Text: | Download PDF

Show Abstract
In this paper we study the ability of array-based networks to tolerate worst-case faults. We show that an $N \times N$ two-dimensional array can sustain $N^{1-\epsilon}$ worst-case faults, for any fixed $\epsilon > 0$, and still emulate $T$ steps of a fully functioning $N \times N$ array in $O(T+N)$ steps, i.e., with only constant slowdown. Previously, it was known only that an array could tolerate a constant number of faults with constant slowdown. We also show that iffaulty nodes are allowed to communicate, but not compute, then an $N$-node one-dimensional array can tolerate $\log^k N$ worst-case faults, for any constant $k > 0$, and still emulate a fault-free array with constant slowdown, and this bound is tight.

Matrix Searching with the Shortest-Path Metric

John Hershberger and Subhash Suri

SIAM J. Comput. 26, pp. 1612-1634 (23 pages) | Cited 1 time

Online Publication Date: July 28, 2006

Full Text: | Download PDF

Show Abstract
We present an O(n) time algorithm for computing row-wise maxima or minima of an implicit, totally monotone $n \times n$ matrix whose entries represent shortest-path distances between pairs of vertices in a simple polygon. We apply this result to derive improved algorithms for several well-known problems in computational geometry. Most prominently, we obtain linear-time algorithms for computing the geodesic diameter, all farthest neighbors, and external farthest neighbors of a simple polygon, improving the previous best result by a factor of O(log n) in each case.

Randomized $\tilde{O}(M(|V|))$ Algorithms for Problems in Matching Theory

Joseph Cheriyan

SIAM J. Comput. 26, pp. 1635-1655 (21 pages) | Cited 3 times

Online Publication Date: July 28, 2006

Full Text: | Download PDF

Show Abstract
A randomized (Las Vegas) algorithm is given for finding the Gallai--Edmonds decomposition of a graph. Let n denote the number of vertices, and let M(n) denote the number of arithmetic operations for multiplying two n $\times$ n matrices. The sequential running time (i.e., number of bit operations) is within a poly-logarithmic factor of M(n). The parallel complexity is O((log n)2) parallel time using a number of processors within a poly-logarithmic factor of M(n). The same complexity bounds suffice for solving several other problems: finding a minimum vertex cover in a bipartite graphfinding a minimum X ---> Y vertex separator in a directed graph, where X and Y are specified sets of vertices,finding the allowed edges (i.e., edges that occur in some maximum matching) of a graph,finding the canonical partition of the vertex set of an elementary graph.
The sequential algorithms for problems (i), (ii), and (iv) are Las Vegas, and the algorithm for problem (iii) is Monte Carlo. The new complexity bounds are significantly better than the best previous ones, e.g., using the best value of M(n) currently known, the new sequential running time is O(n2.38) versus the previous best O(n2.5 /(log n)) or more.

Maximum Agreement Subtree in a Set of Evolutionary Trees: Metrics and Efficient Algorithms

Amihood Amir and Dmitry Keselman

SIAM J. Comput. 26, pp. 1656-1669 (14 pages) | Cited 6 times

Online Publication Date: July 28, 2006

Full Text: | Download PDF

Show Abstract
The maximum agreement subtree approach is one method of reconciling different evolutionary trees for the same set of species. An agreement subtree enables choosing a subset of the species for whom the restricted subtree is equivalent (under a suitable definition) in all given evolutionary trees.
Recently, dynamic programming ideas were used to provide polynomial time algorithms for finding a maximum homeomorphic agreement subtree of two trees. Generalizing these methods to sets of more than two trees yields algorithms that are exponential in the number of trees. Unfortunately, it turns out that in reality one is usually presented with more than two trees, sometimes as many as thousands of trees.
In this paper we prove that the maximum homeomorphic agreement subtree problem is $\cal{NP}$-complete for three trees with unbounded degrees. We then show an approximation algorithm of time O(kn5) for choosing the species that are not in a maximum agreement subtree of a set of k trees. Our approximation is guaranteed to provide a set that is no more than 4 times the optimum solution.
While the set of evolutionary trees may be large in practice, the trees usually have very small degrees, typically no larger than three. We develop a new method for finding a maximum agreement subtree of k trees, of which one has degree bounded by d. This new method enables us to find a maximum agreement subtree in time O(knd + 1+ n2d).

The Union of Convex Polyhedra in Three Dimensions

Boris Aronov, Micha Sharir, and Boaz Tagansky

SIAM J. Comput. 26, pp. 1670-1688 (19 pages) | Cited 7 times

Online Publication Date: July 28, 2006

Full Text: | Download PDF

Show Abstract
We show that the number of vertices, edges, and faces of the union of k convex polyhedra in 3-space, having a total of n faces, is O(k3 + kn log k). This bound is almost tight in the worst case, as there exist collections of polyhedra with $\Omega(k^3+kn\alpha(k))$ union complexity. We also describe a rather simple randomized incremental algorithm for computing the boundary of the union in O(k3 + kn log k log n) expected time.

Star Unfolding of a Polytope with Applications

Pankaj K. Agarwal, Boris Aronov, Joseph O'Rourke, and Catherine A. Schevon

SIAM J. Comput. 26, pp. 1689-1713 (25 pages) | Cited 7 times

Online Publication Date: July 28, 2006

Full Text: | Download PDF

Show Abstract
We introduce the notion of a star unfolding of the surface ${\cal P}$ of a three-dimensional convex polytope with n vertices, and use it to solve several problems related to shortest paths on ${\cal P}$.
The first algorithm computes the edge sequences traversed by shortest paths on ${\cal P}$ in time $O(n^6 \beta (n) \log n)$, where $\beta (n)$ is an extremely slowly growing function. A much simpler $O(n^6)$ time algorithm that finds a small superset of all such edge sequences is also sketched.
The second algorithm is an $O(n^{8}\log n)$ time procedure for computing the geodesic diameter of ${\cal P}$: the maximum possible separation of two points on ${\cal P}$ with the distance measured along ${\cal P}$.
Finally, we describe an algorithm that preprocesses ${\cal P}$ into a data structure that can efficiently answer the queries of the following form: "Given two points, what is the length of the shortest path connecting them?" Given a parameter $1 \le m \le n^2$, it can preprocess ${\cal P}$ in time $O(n^6 m^{1+\delta})$, for any $\delta > 0$, into a data structure of size $O(n^6m^{1+\delta})$, so that a query can be answered in time $O((\sqrt{n}/m^{1/4}) \log n)$. If one query point always lies on an edge of ${\cal P}$, the algorithm can be improved to use $O(n^5 m^{1+\delta})$ preprocessing time and storage and guarantee $O((n/m)^{1/3} \log n)$ query time for any choice of $m$ between 1 and $n$.

Computing Envelopes in Four Dimensions with Applications

Pankaj K. Agarwal, Boris Aronov, and Micha Sharir

SIAM J. Comput. 26, pp. 1714-1732 (19 pages) | Cited 7 times

Online Publication Date: July 28, 2006

Full Text: | Download PDF

Show Abstract
Let ${\cal F}$ be a collection of nd-variate, possibly partially defined, functions, all algebraic of some constant maximum degree. We present a randomized algorithm that computes the vertices, edges, and 2-faces of the lower envelope (i.e., pointwise minimum) of ${\cal F}$ in expected time $O(n^{d+\epsilon})$ for any $\epsilon > 0$. For d = 3, by combining this algorithm with the point-location technique of Preparata and Tamassia, we can compute, in randomized expected time $O(n^{3+\epsilon})$, for any $\epsilon > 0$, a data structure of size $O(n^{3+\epsilon})$ that, for any query point q, can determine in O(log2n) time the function(s) of ${\cal F}$ that attain the lower envelope at q. As a consequence, we obtain improved algorithmic solutions to several problems in computational geometry, including (a) computing the width of a point set in 3-space, (b) computing the "biggest stick" in a simple polygon in the plane, and (c) computing the smallest-width annulus covering a planar point set. The solutions to these problems run in randomized expected time $O(n^{17/11+\epsilon})$, for any $\epsilon > 0$, improving previous solutions that run in time $O(n^{8/5+\epsilon})$. We also present data structures for (i) performing nearest-neighbor and related queries for fairly general collections of objects in 3-space and for collections of moving objects in the plane and (ii) performing ray-shooting and related queries among n spheres or more general objects in 3-space. Both of these data structures require $O(n^{3+\epsilon})$ storage and preprocessing time, for any $\epsilon > 0$, and support polylogarithmic-time queries. These structures improve previous solutions to these problems.

A Spectral Technique for Coloring Random 3-Colorable Graphs

Noga Alon and Nabil Kahale

SIAM J. Comput. 26, pp. 1733-1748 (16 pages) | Cited 17 times

Online Publication Date: July 28, 2006

Full Text: | Download PDF

Show Abstract
Let G3n,p,3 be a random 3-colorable graph on a set of 3n vertices generated as follows. First, split the vertices arbitrarily into three equal color classes, and then choose every pair of vertices of distinct color classes, randomly and independently, to be edges with probability p. We describe a polynomial-time algorithm that finds a proper 3-coloring of G3n,p,3 with high probability, whenever p $\geq$ c/n, where c is a sufficiently large absolute constant. This settles a problem of Blum and Spencer, who asked if an algorithm can be designed that works almost surely for p $\geq$ polylog(n)/n [J. Algorithms, 19 (1995), pp. 204--234]. The algorithm can be extended to produce optimal k-colorings of random k-colorable graphs in a similar model as well as in various related models. Implementation results show that the algorithm performs very well in practice even for moderate values of c.

A Fast Algorithm for the Computation and Enumeration of Perfect Phylogenies

Sampath Kannan and Tandy Warnow

SIAM J. Comput. 26, pp. 1749-1763 (15 pages) | Cited 11 times

Online Publication Date: July 28, 2006

Full Text: | Download PDF

Show Abstract
The perfect phylogeny problem is a classical problem in computational evolutionary biology, in which a set of species/taxa is described by a set of qualitative characters. In recent years, the problem has been shown to be NP-complete in general, while the different fixed parameter versions can each be solved in polynomial time. In particular, Agarwala and Fernández-Baca have developed an O(23r (nk3 + k4)) algorithm for the perfect phylogeny problem for n species defined by kr-state characters [SIAM J. Comput., 23 (1994), pp. 1216--1224]. Since, commonly, the character data are drawn from alignments of molecular sequences, k is the length of the sequences and can thus be very large (in the hundreds or thousands). Thus, it is imperative to develop algorithms which run efficiently for large values of k. In this paper we make additional observations about the structure of the problem and produce an algorithm for the problem that runs in time O(22rk2n). We also show how it is possible to efficiently build a structure that implicitly represents the set of all perfect phylogenies and to randomly sample from that set.

Fault-Tolerant Meshes with Small Degree

Jehoshua Bruck, Robert Cypher, and Ching-Tien Ho

SIAM J. Comput. 26, pp. 1764-1784 (21 pages) | Cited 5 times

Online Publication Date: July 28, 2006

Full Text: | Download PDF

Show Abstract
This paper presents constructions for fault-tolerant, two-dimensional mesh architectures. The constructions are designed to tolerate $k$ faults while maintaining a healthy n by n mesh as a subgraph. They utilize several novel techniques for obtaining trade-offs between the number of spare nodes and the degree of the fault-tolerant network.
We consider both worst-case and random fault distributions. In terms of worst-case faults, we give a construction that has constant degree and O(k3) spare nodes. This is the first construction known in which the degree is constant and the number of spare nodes is independent of n. In terms of random faults, we present several new degree-6 and degree-8 constructions and show (both analytically and through simulations) that these constructions can tolerate large numbers of randomly placed faults.

On Translational Motion Planning of a Convex Polyhedron in 3-Space

Boris Aronov and Micha Sharir

SIAM J. Comput. 26, pp. 1785-1803 (19 pages) | Cited 4 times

Online Publication Date: July 28, 2006

Full Text: | Download PDF

Show Abstract
Let B be a convex polyhedron translating in 3-space amidst k convex polyhedral obstacles A1,...,Ak with pairwise disjoint interiors. The free configuration space (space of all collision-free placements) of B can be represented as the complement of the union of the Minkowski sums $P_i=A_i\oplus (-B)$, for i= 1,...,k. We show that the combinatorial complexity of the free configuration space of B is O(nk log k), and that it can be $\Omega(nk\alpha(k))$ in the worst case, where n is the total complexity of the individual Minkowski sums P1,...,Pk. We also derive an efficient randomized algorithm that constructs this configuration space in expected time O(nk log k log n).
Close

Your Recent History Recent History Help

Recently Viewed

  1. Erratum: Fast Parallel Computation of the Polynomial Remainder Sequence via Bezout and Hankel Matric...
  2. A New Insight into the Coffman–Graham Algorithm
  3. Communication-Space Tradeoffs for Unrestricted Protocols
  4. Tight Worst-Case Performance Bounds for Next-$k$-Fit Bin Packing
  5. On the Boundedness of Constant-Time-Maintainable Database Schemes
© SIAM By using SIAM Publications Online you agree to abide by the Terms and Conditions of Use. Banner art adapted from a figure by Hinke M. Osinga and Bernd Krauskopf (University of Bristol, UK).
close