SIAM Digital Library
 
 
 

SIAM J. on Computing

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

Search Issue | RSS Feeds RSS
Previous Issue

1994

Volume 23, Issue 6, pp. 1093-1347


A Grammar-Based Approach Towards Unifying Hierarchical Data Models

Marc Gyssens, Jan Paredaens, and Dirk Van Gucht

SIAM J. Comput. 23, pp. 1093-1137 (45 pages) | Cited 2 times

Online Publication Date: July 13, 2006

Full Text: | Download PDF

Show Abstract
A simple model for representing the hierarchical structure of information is proposed. This model, called the grammatical model, is based on trees that are generated by grammars; the grammars describe the hierarchy of the information represented by the trees. Two methods for querying in this data model are given. The first, called the grammatical algebra, is based on a set of primitive grammar-oriented operators, the second, called the grammatical calculus, on local transformations on the trees. The semantics of both is formally defined. Decidability issues regarding the grammatical calculus are investigated. Finally, the two querying methods are proved to be equally expressive.

Selecting Heavily Covered Points

Bernard Chazelle, Herbert Edelsbrunner, Leonidas J. Guibas, John E. Hershberger, Raimund Seidel, and Micha Sharir

SIAM J. Comput. 23, pp. 1138-1151 (14 pages)

Online Publication Date: July 13, 2006

Full Text: | Download PDF

Show Abstract
A collection of geometric selection lemmas is proved, such as the following: For any set $P$ of $n$ points in three-dimensional space and any set $S$ of $m$ spheres, where each sphere passes through a distinct point pair in $P$, there exists a point $x$, not necessarily in $P$, that is enclosed by $\Omega ({{m^2 } / {(n^2 \log ^6 \tfrac{{n^2 }}{m})}})$ of the spheres in $S$. Similar results apply in arbitrary fixed dimensions, and for geometric bodies other than spheres. The results have applications in reducing the size of geometric structures, such as three-dimensional Delaunay triangulations and Gabriel graphs, by adding extra points to their defining sets.

Distributed Algorithms For Unidirectional Networks

Yehuda Afek and Eli Gafni

SIAM J. Comput. 23, pp. 1152-1178 (27 pages)

Online Publication Date: July 13, 2006

Full Text: | Download PDF

Show Abstract
This paper addresses the question of distributively computing over a strongly connected unidirectional data communication network. In unidirectional networks the existence of a communication link from one node to another does not imply the existence of a link in the opposite direction. The strong connectivity means that from every node there is a directed path to any other node. The authors assume an arbitrary topology network in which the strong connectivity is the only restriction. Four models are considered, synchronous and asynchronous, and for each node space availability, which grows as either $O(1)$ bits or $O(\log n)$ bits per incident link, where $n$ is the total number of nodes in the network, is considered.
First algorithms for two basic problems in distributed computing in data communication networks, traversal, and election, are provided. Each of these basic protocols produces two directed spanning trees rooted at a distinguished node in the network, one called in-tree, leading to the root, and the other, out-tree, leading from the root. Given these trees, the authors efficiently transform bidirectional algorithms to run on unidirectional networks, and in particular solve other problems such as the broadcast and echo [E. J. CHANG, Decentralized Algorithms in Distributed Systems, Ph.D. thesis, University of Toronto. October 19791 in a way that is more efficient $O(n^2 )$ messages) than direct transformation (which yields $O(nm)$ messages algorithm). The communication cost of the traversal and election algorithms is $O(nm + n^2 \log n)$ bits ($O(nm)$ messages and time), where $m$ is the total number of links in the network. The traversal algorithms for unidirectional networks of finite automata achieve the same cost $O(nm + n^2 \log n)$ bits ($O(nm)$ messages and time) bits) in the asynchronous case, while in the synchronous case the communication cost of the algorithm is ($O(nm)$ bits.

Simple and Fast Algorithms for Linear and Integer Programs with Two Variables Per Inequality

Dorit S. Hochbaum and Joseph (Seffi) Naor

SIAM J. Comput. 23, pp. 1179-1192 (14 pages) | Cited 26 times

Online Publication Date: July 13, 2006

Full Text: | Download PDF

Show Abstract
The authors present an $O(mn^2 \log m)$ algorithm for solving feasibility in linear programs with up to two variables per inequality which is derived directly from the Fourier–Motzkin elimination method. (The number of variables and inequalities are denoted by $n$ and $m$, respectively.) The running time of the algorithm dominates that of the best known algorithm for the problem, and is far simpler. Integer programming on monotone inequalities, i.e., inequalities where the coefficients are of opposite sign, is then considered. This problem includes as a special case the simultaneous approximation of a rational vector with specified accuracy, which is known to be NP-complete. However, it is shown that both a feasible solution and an optimal solution with respect to an arbitrary objective function can be computed in pseudo-polynomial time.

Computing the Order of a Locally Testable Automaton

Sam M. Kim and Robert McNaughton

SIAM J. Comput. 23, pp. 1193-1215 (23 pages) | Cited 3 times

Online Publication Date: July 13, 2006

Full Text: | Download PDF

Show Abstract
A locally testable language is a language with the property that, for some positive integer $j$, whether or not a string $x$ is in the language depends on (1) the prefix and suffix of $x$ of length $j - 1$, and (2) the set of substrings of $x$ of length $j$, without regard to the order in which these substrings occur or the number of times each substring occurs. For any $j$ for which this is true, it is said that the language is $j$ -testable For a given locally testable language, the smallest such number $j$ is called the order of the language. Locally testable languages are regular and therefore these concepts apply to the finite automata that recognize the languages. The authors show that computing the order of a given locally testable deterministic automaton is NP-hard and present a polynomial-time $ \epsilon $-approximation algorithm for computing it. In addition, an upper bound of $2n^2 + 1$ on the order of a locally testable automaton of $n$ states is obtained, and the co-NP-completeness of the problem of whether, for a given $j$, a given deterministic automaton is $j$ -testable is proven.

A Polynomial-Time Algorithm For the Perfect Phylogeny Problem When the Number of Character States is Fixed

Richa Agarwala and David Fernández-Baca

SIAM J. Comput. 23, pp. 1216-1224 (9 pages) | Cited 19 times

Online Publication Date: July 13, 2006

Full Text: | Download PDF

Show Abstract
This paper presents a polynomial-time algorithm for determining whether a set of species, described by the characters they exhibit, has a perfect phylogeny, assuming the maximum number of possible states for a character is fixed. This solves a longstanding open problem. This result should be contrasted with the proof by Steel [J. Classification, 9(1992), pp. 91–1161 and Bodlaender, Fellows, and Warnow [Proceedings of the 19th International Colloquium on Automata, Languages, and Programming, Lecture Notes in Computer Science, 1992, pp. 273–2831 that the perfect phylogeny problem is NP complete in general.

Priority Queues and Permutations

M. D. Atkinson and Robert Beals

SIAM J. Comput. 23, pp. 1225-1230 (6 pages)

Online Publication Date: July 13, 2006

Full Text: | Download PDF

Show Abstract
A priority queue transforms an input permutation $\sigma $ of some set of size $n$ into an output permutation $\tau $ The set $R_n $ of such related pairs $(\sigma ,\tau )$ is studied. Efficient algorithms for determining $s(\tau ) = |\sigma :(\sigma ,\tau ) \in R_n |$, and $t(\sigma ) = |\tau :(\sigma ,\tau ) \in R_n |$ are given, a new proof that $|R_n | = (n + 1)^{n - 1} $ is given, and the transitive closure of $R_n $ is found.

A Model for Asynchronous Shared Memory Parallel Computation

Naomi Nishimura

SIAM J. Comput. 23, pp. 1231-1252 (22 pages) | Cited 1 time

Online Publication Date: July 13, 2006

Full Text: | Download PDF

Show Abstract
Traditional theoretical shared memory parallel models have been based on a number of assumptions which simultaneously simplify solutions to problems and distance the models from actual parallel machines. One such assumption is that processors work together in a synchronous fashion. Recent work has focused on finding a model that captures the essence of computation by processors communicating asynchronously through shared memory. In this paper, a general framework and set of criteria used to analyze these models, including the complexity analysis of several fundamental algorithmic paradigms, are considered. A general asynchronous model is introduced and how it satisfies these criteria is demonstrated. In this model, $O(\log p)$ algorithms are demonstrated for solving $p$-input versions of the problems of AND, OR, parity, maximum, minimum, and list ranking. To handle list ranking, a technique of analyzing algorithms is developed in which the set of tasks that are to be executed depends on the processor schedules.

Tight Bounds on Oblivious Chaining

Shiva Chaudhuri

SIAM J. Comput. 23, pp. 1253-1265 (13 pages)

Online Publication Date: July 13, 2006

Full Text: | Download PDF

Show Abstract
The chaining problem is defined as follows. Given values at $a_1 , \ldots ,a_n ,a_i = 0$ or 1, $1 \leqslant i \leqslant n$, compute $b_1 , \ldots ,b_n $ such that $b_i = \max \{ j|a_j = 1,j < i\} $. (Define $\max \{ \} = 0$.) The chaining problem appears as a subproblem in many contexts. There are known algorithms that solve the chaining problem on CROW PRAMs in $O(\alpha (n))$ time, where $\alpha (n)$ is the inverse of Ackerman’s function, and is a very slowly growing function. The author studies a class of algorithms (called oblivious algorithms) for this problem. A simple oblivious chaining algorithm running in $O(\alpha (n))$ time is presented. More importantly, the optimality of the algorithm is demonstrated by showing a matching lower bound for oblivious algorithms using n processors. The first steps toward a lower bound for all chaining algorithms are also provided by showing that any chaining algorithm that runs in two steps must use a superlinear number of processors. The proofs use prefix graphs and weak superconcentrators An interesting connection between the two is demonstrated and this idea is used to obtain improved bounds on the size of prefix graphs.

Requirements for Deadlock-Free, Adaptive Packet Routing

Robert Cypher and Luis Gravano

SIAM J. Comput. 23, pp. 1266-1274 (9 pages) | Cited 2 times

Online Publication Date: July 13, 2006

Full Text: | Download PDF

Show Abstract
This paper studies the problem of deadlock-free packet routing in parallel and distributed architectures. Three main results are presented. First, it is shown that the standard technique of ordering the buffers so that every packet always has the possibility of moving to a higher-ordered buffer is not necessary for deadlock freedom. Second, it is shown that every deadlock-free, adaptive packet routing algorithm can be restricted, by limiting the adaptivity available, to obtain an oblivious algorithm which is also deadlock-free. Third, it is shown that any packet routing algorithm for a cycle or torus network which is free of deadlock and which uses only minimal length paths must require at least three buffers in some node. This matches the known upper bound of three buffers per node for deadlock-free, minimal packet routing on cycle and torus networks.

On Languages Reducible to Algorithmically Random Languages

Ronald V. Book

SIAM J. Comput. 23, pp. 1275-1282 (8 pages)

Online Publication Date: July 13, 2006

Full Text: | Download PDF

Show Abstract
In this paper languages “bounded reducible” to algorithmically random languages are studied; these are the languages whose characteristic sequences are algorithmically random (as defined by Martin-Löf [Inform. and Control, 9(), pp. 602–619]); here RAND denotes the class of algorithmically random languages. The reducibilities $ \leqslant ^\mathcal{R} $ are very general but are defined so that if $A \in \mathcal{R}(B)$, then there is a machine $M$ with the properties that $L(M,B) = A$ and every computation of $M$ relative to any oracle halts.
Book, Lutz, and Wagner [Math. Systems Theory, 27 (1994), pp. 201–209] studied ALMOST-$\mathcal{R}$, defined to be { $A|$ for almost every $B$, $A \leqslant _\mathcal{R} B$ }. They showed that ALMOST-$\mathcal{R} = \mathcal{R}({\text{RAND}}) \cap {\text{REC}}$, where ${\text{REC}}$ denotes the class of recursive languages, so that ALMOST-$\mathcal {R}$ is the “recursive part” of $\mathcal{R}({\text{Rand}})$. In this paper this characterization is strengthened by showing that for every$B \in {\text{RAND}}$, ALMOST-$\mathcal{R} = \mathcal{R}({B{RAND}}) \cap {\text{REC}}$. A pair $(A,B)$ of languages is an independent pair of algorithmically random languages if $A \oplus B \in {\text{RAND}}$. In this paper it is shown that for every $\mathcal {R}$ and for every independent pair $(A,B)$, ALMOST-$\mathcal {R} = \mathcal{R}(A) \cap \mathcal{R}(B)$.

A Fast Algorithm For Optimum Height-Limited Alphabetic Binary Trees

Lawrence L. Larmore and Teresa M. Przytycka

SIAM J. Comput. 23, pp. 1283-1312 (30 pages) | Cited 4 times

Online Publication Date: July 13, 2006

Full Text: | Download PDF

Show Abstract
In this paper, an $O(nL\log n)$-time algorithm is presented for construction of an optimal alphabetic binary tree with height restricted to $L$. This algorithm is an alphabetic version of the Package Merge algorithm, and yields an $O(nL\log n)$-time algorithm for the alphabetic Huffman coding problem. The Alphabetic Package Merge algorithm is quite simple to describe, but appears hard to prove correct.
Garey [SIAM J Comput., 3 (1974), pp. 101–110] gives an $O(n^3 \log n)$-time algorithm for the height-limited alphabetic binary tree problem. Itai [SIAM J. Comput., 5 (1976), pp. 9–18] and Wessner [Inform. Process. Lett., 4 (1976), pp. 90–94] independently reduce this time to $O(n^2 L)$ for the alphabetic problem. In [SIAM J. Comput., 16 (1987), pp. 1115–1123], a rather complex $O(n^{{3 / 2}} L\log ^{{1 / 2}} n)$ -time “hybrid” algorithm is given for length-limited Huffman coding. The Package Merge algorithm, discussed in this paper, first appeared in [Tech. Report, 88-01, ICS Dept. Univ. of California, Irvine, CA], but without proof of correctness.

Improved Algorithms For Linear Inequalities with Two Variables Per Inequality

Edith Cohen and Nimrod Megiddo

SIAM J. Comput. 23, pp. 1313-1347 (35 pages) | Cited 6 times

Online Publication Date: July 13, 2006

Full Text: | Download PDF

Show Abstract
The authors show that a system of $m$ linear inequalities with $n$ variables, where each inequality involves at most two variables, can be solved in $\tilde O(mn^2 )$ time (we denote $\tilde O(f) = O(f{\operatorname{polylog}} n{\operatorname{polylog}} m))$ deterministically, and in $\tilde O(n^3 + mn)$ expected time using randomization. Parallel implementations of these algorithms run in $\tilde O(n)$ time, where the deterministic algorithm uses $\tilde O(mn)$ processors and the randomized algorithm uses $\tilde O(n^2 + m)$ processors. The bounds significantly improve over previous algorithms. The randomized algorithm is based on novel insights into the structure of the problem.
Close

Your Recent History Recent History Help

Recently Viewed

  1. Tight Worst-Case Performance Bounds for Next-$k$-Fit Bin Packing
  2. 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