Results 1  10
of
25
Computing MinimumWeight Perfect Matchings
 INFORMS
, 1999
"... We make several observations on the implementation of Edmonds’ blossom algorithm for solving minimumweight perfectmatching problems and we present computational results for geometric problem instances ranging in size from 1,000 nodes up to 5,000,000 nodes. A key feature in our implementation is the ..."
Abstract

Cited by 85 (2 self)
 Add to MetaCart
We make several observations on the implementation of Edmonds’ blossom algorithm for solving minimumweight perfectmatching problems and we present computational results for geometric problem instances ranging in size from 1,000 nodes up to 5,000,000 nodes. A key feature in our implementation is the use of multiple search trees with an individual dualchange � for each tree. As a benchmark of the algorithm’s performance, solving a 100,000node geometric instance on a 200 Mhz PentiumPro computer takes approximately 3 minutes.
Nearest Common Ancestors: A survey and a new distributed algorithm
, 2002
"... Several papers describe linear time algorithms to preprocess a tree, such that one can answer subsequent nearest common ancestor queries in constant time. Here, we survey these algorithms and related results. A common idea used by all the algorithms for the problem is that a solution for complete ba ..."
Abstract

Cited by 76 (11 self)
 Add to MetaCart
Several papers describe linear time algorithms to preprocess a tree, such that one can answer subsequent nearest common ancestor queries in constant time. Here, we survey these algorithms and related results. A common idea used by all the algorithms for the problem is that a solution for complete balanced binary trees is straightforward. Furthermore, for complete balanced binary trees we can easily solve the problem in a distributed way by labeling the nodes of the tree such that from the labels of two nodes alone one can compute the label of their nearest common ancestor. Whether it is possible to distribute the data structure into short labels associated with the nodes is important for several applications such as routing. Therefore, related labeling problems have received a lot of attention recently.
Optimal preprocessing for answering online product queries
, 1987
"... We examine the amount of preprocessing needed for answering certain online queries as fast as possible. We start with the following basic problem. Suppose we are given a semigroup (S,°). Let s 1,..., sn be elements of S. We want to answer online queries of the form, "What is the product s ..."
Abstract

Cited by 56 (3 self)
 Add to MetaCart
We examine the amount of preprocessing needed for answering certain online queries as fast as possible. We start with the following basic problem. Suppose we are given a semigroup (S,°). Let s 1,..., sn be elements of S. We want to answer online queries of the form, &quot;What is the product s i°s i +1 ° j −1 j n 1... °s °s? &quot; for any give ≤ i ≤ j ≤ n. We show that a preprocessing of Θ(n λ(k,n)) time and space is both necessary and sufficient to answer each such query in at most k steps, for any fixed k. The function λ(k,.) is the inverse of a certain function at the �k /2 �−th level of the primitive recursive hierarchy. In case linear preprocessing is desired, we show that one can answer each such query in at most O (α(n)) steps and that this is best possible. The function α(n) is the inverse Ackermann function. We also consider the following extended problem. Let T be a tree with an element of S associated with each of its vertices. We want to answer online queries of the form, &quot; What is the product of the elements associated with the vertices along the path from u to v? &quot; for any pair of vertices u and v in T. We derive results, which are similar to the above, for the preprocessing needed for answering such queries. All our sequential preprocessing algorithms can be parallelized efficiently to give optimal parallel algorithms which run in O (logn) time on a CREW PRAM. These parallel algorithms are optimal in both running time and total number of operations.
Efficient detection of determinacy races in Cilk programs
 In Proceedings of the Ninth Annual ACM Symposium on Parallel Algorithms and Architectures (SPAA
, 1997
"... A parallel multithreaded program that is ostensibly deterministic ..."
Abstract

Cited by 51 (15 self)
 Add to MetaCart
A parallel multithreaded program that is ostensibly deterministic
A Simple, Fast Dominance Algorithm
"... The problem of finding the dominators in a controlflow graph has a long history in the literature. The original algorithms su#ered from a large asymptotic complexity but were easy to understand. Subsequent work improved the time bound, but generally sacrificed both simplicity and ease of implemen ..."
Abstract

Cited by 31 (0 self)
 Add to MetaCart
The problem of finding the dominators in a controlflow graph has a long history in the literature. The original algorithms su#ered from a large asymptotic complexity but were easy to understand. Subsequent work improved the time bound, but generally sacrificed both simplicity and ease of implementation. This paper returns to a simple formulation of dominance as a global dataflow problem. Some insights into the natureofdominance lead to an implementation of an O(N )algorithm that runs faster, in practice, than the classic LengauerTarjan algorithm, which has a timebound of O(E log(N)). We compare the algorithm to LengauerTarjan because it is the best known and most widely used of the fast algorithms for dominance. Working from the same implementationinsights,wealso rederive (from earlier work on control dependence by Ferrante, et al.)amethodforcalculating dominance frontiers that we show is faster than the original algorithm by Cytron, et al. The aim of this paper is not to present a new algorithm, but, rather, to make an argument based on empirical evidence that algorithms with discouraging asymptotic complexities can be faster in practice than those more commonly employed. We show that, in some cases, careful engineering of simple algorithms can overcome theoretical advantages, even when problems grow beyond realistic sizes. Further, we argue that the algorithms presented herein are intuitive and easily implemented, making them excellent teaching tools.
LinearTime PointerMachine Algorithms for Least Common Ancestors, MST Verification, and Dominators
 IN PROCEEDINGS OF THE THIRTIETH ANNUAL ACM SYMPOSIUM ON THEORY OF COMPUTING
, 1998
"... We present two new data structure toolsdisjoint set union with bottomup linking, and pointerbased radix sortand combine them with bottomlevel microtrees to devise the first lineartime pointermachine algorithms for offline least common ancestors, minimum spanning tree (MST) verification, ..."
Abstract

Cited by 27 (4 self)
 Add to MetaCart
We present two new data structure toolsdisjoint set union with bottomup linking, and pointerbased radix sortand combine them with bottomlevel microtrees to devise the first lineartime pointermachine algorithms for offline least common ancestors, minimum spanning tree (MST) verification, randomized MST construction, and computing dominators in a flowgraph.
Dominators in Linear Time
, 1997
"... A linear time algorithm is presented for finding dominators in control flow graphs. ..."
Abstract

Cited by 25 (0 self)
 Add to MetaCart
A linear time algorithm is presented for finding dominators in control flow graphs.
Theoretical and practical improvements on the RMQproblem, with applications to LCA and LCE
 PROC. CPM. VOLUME 4009 OF LNCS
, 2006
"... The RangeMinimumQueryProblem is to preprocess an array such that the position of the minimum element between two specified indices can be obtained efficiently. We present a direct algorithm for the general RMQproblem with linear preprocessing time and constant query time, without making use of ..."
Abstract

Cited by 21 (9 self)
 Add to MetaCart
The RangeMinimumQueryProblem is to preprocess an array such that the position of the minimum element between two specified indices can be obtained efficiently. We present a direct algorithm for the general RMQproblem with linear preprocessing time and constant query time, without making use of any dynamic data structure. It consumes less than half of the space that is needed by the method by Berkman and Vishkin. We use our new algorithm for RMQ to improve on LCAcomputation for binary trees, and further give a constanttime LCEalgorithm solely based on arrays. Both LCA and LCE have important applications, e.g., in computational biology. Experimental studies show that our new method is almost twice as fast in practice as previous approaches, and asymptotically slower variants of the constanttime algorithms perform even better for today’s common problem sizes.
A shortest path algorithm for realweighted undirected graphs
 in 13th ACMSIAM Symp. on Discrete Algs
, 1985
"... Abstract. We present a new scheme for computing shortest paths on realweighted undirected graphs in the fundamental comparisonaddition model. In an efficient preprocessing phase our algorithm creates a linearsize structure that facilitates singlesource shortest path computations in O(m log α) ti ..."
Abstract

Cited by 12 (3 self)
 Add to MetaCart
Abstract. We present a new scheme for computing shortest paths on realweighted undirected graphs in the fundamental comparisonaddition model. In an efficient preprocessing phase our algorithm creates a linearsize structure that facilitates singlesource shortest path computations in O(m log α) time, where α = α(m, n) is the very slowly growing inverseAckermann function, m the number of edges, and n the number of vertices. As special cases our algorithm implies new bounds on both the allpairs and singlesource shortest paths problems. We solve the allpairs problem in O(mnlog α(m, n)) time and, if the ratio between the maximum and minimum edge lengths is bounded by n (log n)O(1) , we can solve the singlesource problem in O(m + nlog log n) time. Both these results are theoretical improvements over Dijkstra’s algorithm, which was the previous best for real weighted undirected graphs. Our algorithm takes the hierarchybased approach invented by Thorup. Key words. singlesource shortest paths, allpairs shortest paths, undirected graphs, Dijkstra’s
On Space Efficient Two Dimensional Range Minimum Data Structures
"... Abstract. The two dimensional range minimum query problem is to preprocess a static two dimensional m by n array A of size N = m · n, such that subsequent queries, asking for the position of the minimum element in a rectangular range within A, can be answered efficiently. We study the tradeoff betw ..."
Abstract

Cited by 8 (3 self)
 Add to MetaCart
Abstract. The two dimensional range minimum query problem is to preprocess a static two dimensional m by n array A of size N = m · n, such that subsequent queries, asking for the position of the minimum element in a rectangular range within A, can be answered efficiently. We study the tradeoff between the space and query time of the problem. We show that every algorithm enabled to access A during the query and using O(N/c) bits additional space requires Ω(c) query time, for any c where 1 ≤ c ≤ N. This lower bound holds for any dimension. In particular, for the one dimensional version of the problem, the lower bound is tight up to a constant factor. In two dimensions, we complement the lower bound with an indexing data structure of size O(N/c) bits additional space which can be preprocessed in O(N) time and achieves O(c log 2 c) query time. For c = O(1), this is the first O(1) query time algorithm using optimal O(N) bits additional space. For the case where queries can not probe A, we give a data structure of size O(N · min{m, log n}) bits with O(1) query time, assuming m ≤ n. This leaves a gap to the lower bound of Ω(N log m) bits for this version of the problem. 1