Jump to Content
Your Recent History
View CartTop 20 Most Read Articles
April 2012
The 20 articles with the most full-text downloads during the month, in descending order.
 |
SIAM J. Comput. 41, pp. 293-331 (39 pages) Online Publication Date: April 17, 2012
Full Text:
|
Download PDF
|
||
|
Show Abstract
In the framework of Wegman and Carter, a $k$-independent hash function maps any $k$ keys independently. It is known that 5-independent hashing provides good expected performance in applications such as linear probing and second moment estimation for data streams. The classic $5$-independent hash function evaluates a degree 4 polynomial over a prime field containing the key domain $[n]=\{0,\ldots,n-1\}$. Here we present an efficient 5-independent hash function that uses no multiplications. Instead, for any parameter $c$, we make $2c-1$ lookups in tables of size $O(n^{1/c})$. In experiments on different computers, our scheme gained factors of 1.8 to 10 in speed over the polynomial method. We also conducted experiments on the performance of hash functions inside the above applications. In particular, we give realistic examples of inputs that make the most popular 2-independent hash function perform quite poorly. This illustrates the advantage of using schemes with provably good expected performance for all inputs. |
|||
|
|
Simulating Size-constrained Galton–Watson Trees SIAM J. Comput. 41, pp. 1-11 (11 pages) Online Publication Date: January 03, 2012
Full Text:
|
Download PDF
|
||
|
Show Abstract
We discuss various methods for generating random Galton–Watson trees conditional on their sizes being equal to $n$. A linear expected time algorithm is proposed. |
|||
|
|
Bounded Concurrent Time-Stamping SIAM J. Comput. 26, pp. 418-455 (38 pages) Online Publication Date: July 28, 2006
Full Text:
|
Download PDF
|
||
|
Show Abstract
We introduce concurrent time-stamping, a paradigm that allows processes to temporally order concurrent events in an asynchronous shared-memory system. Concurrent time-stamp systems are powerful tools for concurrency control, serving as the basis for solutions to coordination problems such as mutual exclusion, $\ell$-exclusion, randomized consensus, and multiwriter multireader atomic registers. Unfortunately, all previously known methods for implementing concurrent time-stamp systems have been theoretically unsatisfying since they require unbounded-size time-stamps---in other words, unbounded-size memory. This work presents the first bounded implementation of a concurrent time-stamp system, providing a modular unbounded-to-bounded transformation of the simple unbounded solutions to problems such as those mentioned above. It allows solutions to two formerly open problems, the bounded-probabilistic-consensus problem of Abrahamson and the fifo-$\ell$-exclusion problem of Fischer, Lynch, Burns and Borodin, and a more efficient construction of multireader multiwriter atomic registers. |
|||
|
|
Polynomial-Time Algorithms for Prime Factorization and Discrete Logarithms on a Quantum Computer SIAM J. Comput. 26, pp. 1484-1509 (26 pages) Online Publication Date: July 28, 2006
Full Text:
|
Download PDF
|
||
|
Show Abstract
A digital computer is generally believed to be an efficient universal computing device; that is, it is believed able to simulate any physical computing device with an increase in computation time by at most a polynomial factor. This may not be true when quantum mechanics is taken into consideration. This paper considers factoring integers and finding discrete logarithms, two problems which are generally thought to be hard on a classical computer and which have been used as the basis of several proposed cryptosystems. Efficient randomized algorithms are given for these two problems on a hypothetical quantum computer. These algorithms take a number of steps polynomial in the input size, e.g., the number of digits of the integer to be factored. |
|||
|
|
Very Simple Methods for All Pairs Network Flow Analysis SIAM J. Comput. 19, pp. 143-155 (13 pages) Online Publication Date: July 31, 2006
Full Text:
|
Download PDF
|
||
|
Show Abstract
A very simple algorithm for the classical problem of computing the maximum network flow value between every pair of nodes in an undirected, capacitated $n$ node graph is presented; as in the well-known Gomory–Hu method, the method given here uses only $n - 1$ maximum flow computations. Our algorithm is implemented by adding only five simple lines of code to any program that produces a minimum cut; a program to produce an equivalent flow tree, which is a compact representation of the flow values, is obtained by adding only three simple lines of code to any program producing a minimum cut. A very simple version of the Gomory–Hu cut tree method that finds one minimum cut for every pair of nodes is also derived, and it is shown that the seemingly fundamental operation of that method, node contraction, is not needed, nor must crossing cuts be avoided. As a result, this version of the Gomory–Hu method is implemented by adding less than ten simple lines of code to any program that produces a minimum cut. The algorithms in this paper demonstrate that a cut tree of graph $G$ can be computed with $n - 1$ calls to an oracle that alone knows $G$, and that, when given two nodes $s$ and $t$, returns any arbitrary minimum $(s, t)$ cut and its value. |
|||
|
|
Approximate Sparse Recovery: Optimizing Time and Measurements SIAM J. Comput. 41, pp. 436-453 (18 pages) Online Publication Date: April 24, 2012
Full Text:
|
Download PDF
|
||
|
Show Abstract
A Euclidean approximate sparse recovery system consists of parameters $k,N$, an $m$-by-$N$ measurement matrix, $\bm{\Phi}$, and a decoding algorithm, $\mathcal{D}$. Given a vector, ${\mathbf x}$, the system approximates ${\mathbf x}$ by $\widehat {\mathbf x}=\mathcal{D}(\bm{\Phi} {\mathbf x})$, which must satisfy $|\widehat {\mathbf x} - {\mathbf x}|_2\le C |{\mathbf x} - {\mathbf x}_k|_2$, where ${\mathbf x}_k$ denotes the optimal $k$-term approximation to ${\mathbf x}$. (The output $\widehat{\mathbf x}$ may have more than $k$ terms.) For each vector ${\mathbf x}$, the system must succeed with probability at least 3/4. Among the goals in designing such systems are minimizing the number $m$ of measurements and the runtime of the decoding algorithm, $\mathcal{D}$. In this paper, we give a system with $m=O(k \log(N/k))$ measurements—matching a lower bound, up to a constant factor—and decoding time $k\log^{O(1)} N$, matching a lower bound up to a polylog$(N)$ factor. We also consider the encode time (i.e., the time to multiply $\bm{\Phi}$ by $x$), the time to update measurements (i.e., the time to multiply $\bm{\Phi}$ by a 1-sparse $x$), and the robustness and stability of the algorithm (resilience to noise before and after the measurements). Our encode and update times are optimal up to $\log(k)$ factors. The columns of $\bm{\Phi}$ have at most $O(\log^2(k)\log(N/k))$ nonzeros, each of which can be found in constant time. Our full result, a fully polynomial randomized approximation scheme, is as follows. If ${\mathbf x}={\mathbf x}_k+\nu_1$, where $\nu_1$ and $\nu_2$ (below) are arbitrary vectors (regarded as noise), then setting $\widehat {\mathbf x} = \mathcal{D}(\Phi {\mathbf x} + \nu_2)$, and for properly normalized $\bm{\Phi}$, we get $\left|{\mathbf x} - \widehat {\mathbf x}\right|_2^2 \le (1+\epsilon)\left|\nu_1\right|_2^2 + \epsilon\left|\nu_2\right|_2^2$ using $O((k/\epsilon)\log(N/k))$ measurements and $(k/\epsilon)\log^{O(1)}(N)$ time for decoding. |
|||
|
|
An Analysis of Several Heuristics for the Traveling Salesman Problem SIAM J. Comput. 6, pp. 563-581 (19 pages) Online Publication Date: July 31, 2006
Full Text:
|
Download PDF
|
||
|
Show Abstract
Several polynomial time algorithms finding “good,” but not necessarily optimal, tours for the traveling salesman problem are considered. We measure the closeness of a tour by the ratio of the obtained tour length to the minimal tour length. For the nearest neighbor method, we show the ratio is bounded above by a logarithmic function of the number of nodes. We also provide a logarithmic lower bound on the worst case. A class of approximation methods we call insertion methods are studied, and these are also shown to have a logarithmic upper bound. For two specific insertion methods, which we call nearest insertion and cheapest insertion, the ratio is shown to have a constant upper bound of 2, and examples are provided that come arbitrarily close to this upper bound. It is also shown that for any $n\geqq 8$, there are traveling salesman problems with $n$ nodes having tours which cannot be improved by making $n/4$ edge changes, but for which the ratio is $2(1-1/n)$. |
|||
|
|
Approximating the Permanent via Nonabelian Determinants SIAM J. Comput. 41, pp. 332-355 (24 pages) Online Publication Date: April 17, 2012
Full Text:
|
Download PDF
|
||
|
Show Abstract
Since the celebrated work of Jerrum, Sinclair, and Vigoda [J. ACM, 51 (2004), pp. 671–697], we have known that the permanent of a matrix with entries in $\{0,1\}$ can be approximated in randomized polynomial time by using a rapidly mixing Markov chain to sample perfect matchings of a bipartite graph. A separate strand of the literature has pursued the possibility of an alternate, algebraic polynomial-time approximation scheme. These schemes work by replacing each 1 with a random element of an algebra $\mathcal{A}$ and considering the determinant of the resulting matrix. In the case where $\mathcal{A}$ is noncommutative, this determinant can be defined in several ways. We show that for some estimators based on the conventional determinant, the critical ratio of the second moment to the square of the first—and therefore the number of trials we need to obtain a good estimate of the permanent—is $(1 + O(1/d))^n$ when $\mathcal{A}$ is the algebra of $d \times d$ matrices. These results can be extended to group algebras and semisimple algebras in general. We also study the symmetrized determinant of Barvinok, showing that the resulting estimator has small variance when $d$ is large enough. However, if $d$ is constant—the only case in which an efficient algorithm is known—we show that the critical ratio exceeds $2^{n} / n^{O(d)}$. Thus our results do not provide a new polynomial-time approximation scheme for the permanent. Indeed, they suggest that the algebraic approach to approximating the permanent faces significant obstacles. We obtain these results using diagrammatic techniques in which we express matrix products as contractions of tensor products. When these matrices are chosen randomly according to the Gaussian distribution, we can evaluate the trace of these products in terms of the cycle structure of a suitably random permutation. In the symmetrized case, our estimates are then derived by a connection with the character theory of the symmetric group. |
|||
|
|
On the Complexity of Timetable and Multicommodity Flow Problems SIAM J. Comput. 5, pp. 691-703 (13 pages) Online Publication Date: July 13, 2006
Full Text:
|
Download PDF
|
||
|
Show Abstract
A very primitive version of Gotlieb’s timetable problem is shown to be NP-complete, and therefore all the common timetable problems are NP-complete. A polynomial time algorithm, in case all teachers are binary, is shown. The theorem that a meeting function always exists if all teachers and classes have no time constraints is proved. The multicommodity integral flow problem is shown to be NP-complete even if the number of commodities is two. This is true both in the directed and undirected cases. |
|||
|
|
Envy-Free Makespan Approximation SIAM J. Comput. 41, pp. 12-25 (14 pages) Online Publication Date: January 03, 2012
Full Text:
|
Download PDF
|
||
|
Show Abstract
We study envy-free mechanisms for assigning tasks to agents, where every task may take a different amount of time to perform by each agent, and the goal is to get all the tasks done as soon as possible (i.e., minimize the makespan). For indivisible tasks, we put forward an envy-free polynomial mechanism that approximates the minimal makespan to within a factor of $O(\log m)$, where $m$ is the number of machines. This bound is almost tight, as we also show that no envy-free mechanism can achieve a better bound than $\Omega(\log m / \log\log m)$. This improves the recent result of Mu'alem [On multi-dimensional envy-free mechanisms, in Proceedings of the First International Conference on Algorithmic Decision Theory, F. Rossi and A. Tsoukias, eds., Lecture Notes in Comput. Sci. 5783, Springer, Berlin, 2009, pp. 120–131] who introduced the model and gave an upper bound of $(m+1)/2$ and a lower bound of $2-1/m$. For divisible tasks, we show that there always exists an envy-free poly-time mechanism with optimal makespan. Finally, we demonstrate how our mechanism for envy-free makespan minimization can be interpreted as a market clearing problem. |
|||
|
|
Depth-First Search and Linear Graph Algorithms SIAM J. Comput. 1, pp. 146-160 (15 pages) Online Publication Date: July 13, 2006
Full Text:
|
Download PDF
|
||
|
Show Abstract
The value of depth-first search or “backtracking” as a technique for solving problems is illustrated by two examples. An improved version of an algorithm for finding the strongly connected components of a directed graph and at algorithm for finding the biconnected components of an undirect graph are presented. The space and time requirements of both algorithms are bounded by $k_1 V + k_2 E + k_3 $ for some constants $k_1 ,k_2 $, and $k_3 $, where $V$ is the number of vertices and $E$ is the number of edges of the graph being examined. |
|||
|
|
An Optimal Self-Stabilizing Firing Squad SIAM J. Comput. 41, pp. 415-435 (21 pages) Online Publication Date: April 24, 2012
Full Text:
|
Download PDF
|
||
|
Show Abstract
Consider a fully connected network where up to $t$ processes may crash and all processes start in an arbitrary memory state. The self-stabilizing firing squad problem consists of eventually guaranteeing simultaneous response to an external input. This is modeled by requiring that the noncrashed processes “fire” simultaneously if some correct process received an external “go” input, and that they only fire as a response to some process receiving such an input. This paper presents FireSquad, the first self-stabilizing firing squad algorithm. A firing squad algorithm facilitates the use of algorithms that need to start in the same round. It allows a smooth transition between algorithms whose executions need to be disjoint. The FireSquad algorithm combines two forms of fault-tolerance properties: self-stabilization to allow recovery from arbitrary transient errors and resilience to crash failures to handle permanent ones. The FireSquad algorithm is optimal in two respects: (a) once the algorithm is in a safe state, it fires in response to a go input as fast as any other algorithm does, and (b) starting from an arbitrary state, it converges to a safe state as fast as any other algorithm does. |
|||
|
|
A Deterministic Polynomial-Time Approximation Scheme for Counting Knapsack Solutions SIAM J. Comput. 41, pp. 356-366 (11 pages) Online Publication Date: April 19, 2012
Full Text:
|
Download PDF
|
||
|
Show Abstract
Given $n$ elements with nonnegative integer weights $w_1, \ldots, w_n$ and an integer capacity $C$, we consider the counting version of the classic knapsack problem: find the number of distinct subsets whose weights add up to at most the given capacity. We give a deterministic algorithm that estimates the number of solutions to within relative error $1\pm\varepsilon$ in time polynomial in $n$ and $1/\varepsilon$ (fully polynomial approximation scheme). More precisely, our algorithm takes time $O(n^3\varepsilon^{-1}\log(n/\varepsilon))$. Our algorithm is based on dynamic programming. Previously, randomized polynomial-time approximation schemes were known first by Morris and Sinclair via Markov chain Monte Carlo techniques and subsequently by Dyer via dynamic programming and rejection sampling. |
|||
|
|
An Optimal Dynamic Data Structure for Stabbing-Semigroup Queries SIAM J. Comput. 41, pp. 104-127 (24 pages) Online Publication Date: January 24, 2012
Full Text:
|
Download PDF
|
||
|
Show Abstract
Let $S$ be a set of $n$ intervals in $\mathbb{R}$, and let $(\mathbf{S}, +)$ be any commutative semigroup. We assign a weight $\omega(s) \in \mathbf{S}$ to each interval in $S$. For a point $x \in \mathbb{R}$, let $S(x) \subseteq S$ be the set of intervals that contain $x$. Given a point $q \in \mathbb{R}$, the stabbing-semigroup query asks for computing $\sum_{s \in S(q)} \omega(s)$. We propose a linear-size dynamic data structure, under the pointer-machine model, that answers queries in worst-case $O(\log n)$ time and supports both insertions and deletions of intervals in amortized $O(\log n)$ time. It is the first data structure that attains the optimal $O(\log n)$ bound for all three operations. Furthermore, our structure can easily be adapted to external memory, where we obtain a linear-size structure that answers queries and supports updates in $O(\log_B n)$ I/Os, where $B$ is the disk block size. For the restricted case of a nested family of intervals (either every pair of intervals is disjoint or one contains the other), we present a simpler solution based on dynamic trees. |
|||
|
|
Iterated Rounding Algorithms for the Smallest k-Edge Connected Spanning Subgraph SIAM J. Comput. 41, pp. 61-103 (43 pages) Online Publication Date: January 24, 2012
Full Text:
|
Download PDF
|
||
|
Show Abstract
We present the best known algorithms for approximating the minimum-size undirected $k$-edge connected spanning subgraph. For simple graphs our approximation ratio is $1+ {1}/(2k) + O({1}/{k^2})$. The more precise version of this bound requires $k\ge 7$, and for all such $k$ it improves the long-standing performance ratio of Cheriyan and Thurimella [SIAM J. Comput., 30 (2000), pp. 528–560], $1+2/(k+1)$. The improvement comes in two steps. First we show that for simple $k$-edge connected graphs, any laminar family of degree $k$ sets is smaller than the general bound ($n(1+ {3}/{k} + O(1/k\sqrt k))$ versus $2n$). This immediately implies that iterated rounding improves the performance ratio of Cheriyan and Thurimella. The second step carefully chooses good edges for rounding. For multigraphs our approximation ratio is $1+(21/11)k <1+1.91/k$ for any $k>1$. This improves the previous ratio $1+2/k$ [H. N. Gabow, M. X. Goemans, E. Tardos, and D. P. Williamson, Networks, 53 (2009), pp. 345–357]. It is of interest since it is known that for some constant $c>0$, an approximation ratio $\le 1+c/k$ implies $P=NP$. Our approximation ratio extends to the minimum-size Steiner network problem, where $k$ denotes the average vertex demand. The algorithm exploits rounding properties of the first two linear programs in iterated rounding. |
|||
|
|
Generalized Selection and Ranking: Sorted Matrices SIAM J. Comput. 13, pp. 14-30 (17 pages) Online Publication Date: August 02, 2006
Full Text:
|
Download PDF
|
||
|
Show Abstract
A more general version of the well-known selection problem is formulated, in which constraints on the input set are allowed. Selection (and also ranking) problems are solved optimally for the broad class of inputs constrained to be collections of matrices with sorted rows and sorted columns.The characterization of problem complexity includes an asymptotically significant dependency on the rank of the solution element. |
|||
|
|
Fast Pattern Matching in Strings SIAM J. Comput. 6, pp. 323-350 (28 pages) Online Publication Date: July 13, 2006
Full Text:
|
Download PDF
|
||
|
Show Abstract
An algorithm is presented which finds all occurrences of one given string within another, in running time proportional to the sum of the lengths of the strings. The constant of proportionality is low enough to make this algorithm of practical use, and the procedure can also be extended to deal with some more general pattern-matching problems. A theoretical application of the algorithm shows that the set of concatenations of even palindromes, i.e., the language $\{\alpha \alpha ^R\}^*$, can be recognized in linear time. Other algorithms which run even faster on the average are also considered. |
|||
|
|
Randomized Competitive Algorithms for Generalized Caching SIAM J. Comput. 41, pp. 391-414 (24 pages) Online Publication Date: April 19, 2012
Full Text:
|
Download PDF
|
||
|
Show Abstract
We consider online algorithms for the generalized caching problem. Here we are given a cache of size $k$ and pages with arbitrary sizes and fetching costs. Given a request sequence of pages, the goal is to minimize the total cost of fetching the pages into the cache. Our main result is an online algorithm with competitive ratio $O(\log^2k)$, which gives the first $o(k)$ competitive algorithm for the problem. We also give improved $O(\log k)$-competitive algorithms for the special cases of the bit model and fault model, improving upon the previous $O(\log^2k)$ guarantees due to Irani [Proceedings of the 29th Annual ACM Symposium on Theory of Computing, 1997, pp. 701–710]. Our algorithms are based on an extension of the online primal-dual framework introduced by Buchbinder and Naor [Math. Oper. Res., 34 (2009), pp. 270–286] and involve two steps. First, we obtain an $O(\log k)$-competitive fractional algorithm based on solving online an LP formulation strengthened with exponentially many knapsack cover constraints. Second, we design a suitable online rounding procedure to convert this online fractional algorithm into a randomized algorithm. Our techniques provide a unified framework for caching algorithms and are substantially simpler than those previously used. |
|||
|
|
On Clustering to Minimize the Sum of Radii SIAM J. Comput. 41, pp. 47-60 (14 pages) Online Publication Date: January 05, 2012
Full Text:
|
Download PDF
|
||
|
Show Abstract
Let $P$ be a set of $n$ points in the plane. Consider the problem of finding $k$ disks, each centered at a point in $P$, whose union covers $P$ with the objective of minimizing the sum of the radii of the disks. We present an exact algorithm for this well-studied problem with polynomial running time, under the assumption that two candidate solutions can be compared efficiently. The algorithm generalizes in a straightforward manner to any fixed dimension and to some other related problems. |
|||
|
|
A Simple Unpredictable Pseudo-Random Number Generator SIAM J. Comput. 15, pp. 364-383 (20 pages) Online Publication Date: July 13, 2006
Full Text:
|
Download PDF
|
||
|
Show Abstract
Two closely-related pseudo-random sequence generators are presented: The ${1 / P}$generator, with input $P$ a prime, outputs the quotient digits obtained on dividing 1 by $P$. The $x^2 \bmod N$generator with inputs $N$, $x_0 $ (where $N = P \cdot Q$ is a product of distinct primes, each congruent to 3 mod 4, and $x_0 $ is a quadratic residue $\bmod N$), outputs $b_0 b_1 b_2 \cdots $ where $b_i = {\operatorname{parity}}(x_i )$ and $x_{i + 1} = x_i^2 \bmod N$. From short seeds each generator efficiently produces long well-distributed sequences. Moreover, both generators have computationally hard problems at their core. The first generator’s sequences, however, are completely predictable (from any small segment of $2|P| + 1$ consecutive digits one can infer the “seed,” $P$, and continue the sequence backwards and forwards), whereas the second, under a certain intractability assumption, is unpredictable in a precise sense. The second generator has additional interesting properties: from knowledge of $x_0 $ and $N$ but not$P$ or $Q$, one can generate the sequence forwards, but, under the above-mentioned intractability assumption, one can not generate the sequence backwards. From the additional knowledge of $P$ and $Q$, one can generate the sequence backwards; one can even “jump” about from any point in the sequence to any other. Because of these properties, the $x^2 \bmod N$generator promises many interesting applications, e.g., to public-key cryptography. To use these generators in practice, an analysis is needed of various properties of these sequences such as their periods. This analysis is begun here. |
|||
ALL SIAM Content
Scitation
Google Scholar