Showing papers by "Robert E. Tarjan published in 1984"
24 Oct 1984
TL;DR: The structure, Fibonacci heaps (abbreviated F-heaps), extends the binomial queues proposed by Vuillemin and studied further by Brown to obtain improved running times for several network optimization algorithms.
Abstract: In this paper we develop a new data structure for implementing heaps (priority queues). Our structure, Fibonacci heaps (abbreviated F-heaps), extends the binomial queues proposed by Vuillemin and studied further by Brown. F-heaps support arbitrary deletion from an n-item heap in 0(log n) amortized time and all other standard heap operations in 0(1) amortized time. Using F-heaps we are able to obtain improved running times for several network optimization algorithms.
1,757 citations
TL;DR: An algorithm for a random access machine with uniform cost measure (and a bound of $\Omega (\log n)$ on the number of bits per word) that requires time per query and preprocessing time is presented, assuming that the collection of trees is static.
Abstract: We consider the following problem: Given a collection of rooted trees, answer on-line queries of the form, “What is the nearest common ancester of vertices x and y?” We show that any pointer machine that solves this problem requires $\Omega (\log \log n)$ time per query in the worst case, where n is the total number of vertices in the trees. On the other hand, we present an algorithm for a random access machine with uniform cost measure (and a bound of $\Omega (\log n)$ on the number of bits per word) that requires $O(1)$ time per query and $O(n)$ preprocessing time, assuming that the collection of trees is static. For a version of the problem in which the trees can change between queries, we obtain an almost-linear-time (and linear-space) algorithm.
1,252 citations
TL;DR: An article of golfing equipment has a golf tee attached to a spring-biassed reel by a length of string which can be aligned with the green or hole and used as an aid in swinging the club face in the correct direction.
Abstract: Chordal graphs arise naturally in the study of Gaussian elimination on sparse symmetric matrices; acyclic hypergraphs arise in the study of relational data bases. Rose, Tarjan and Lueker [SIAM J. C...
991 citations
TL;DR: This paper considers the problem of finding, for each possible sink vertex v, a pair of edge-disjoint paths from s to v of minimum total edge cost, and gives an implementation of Suurballe's algorithm that runs in O(m log(1+ m/n)n) time and O( m) space.
Abstract: Let G be a directed graph containing n vertices, one of which is a distinguished source s, and m edges, each with a non-negative cost. We consider the problem of finding, for each possible sink vertex v, a pair of edge-disjoint paths from s to v of minimum total edge cost. Suurballe has given an O(n2 logn)-time algorithm for this problem. We give an implementation of Suurballe's algorithm that runs in O(m log(1+ m/n)n) time and O(m) space. Our algorithm builds an implicit representation of the n pairs of paths; given this representation, the time necessary to explicitly construct the pair of paths for any given sink is O(1) per edge on the paths.
758 citations
01 Dec 1984
TL;DR: Three techniques in computational geometry are explored: scaling solves a problem by viewing it at increasing levels of numerical precision; activation is a restricted type of update operation, useful in sweep algorithms; the Cartesian tree is a data structure for problems involving maximums and minimums.
Abstract: Three techniques in computational geometry are explored: Scaling solves a problem by viewing it at increasing levels of numerical precision; activation is a restricted type of update operation, useful in sweep algorithms; the Cartesian tree is a data structure for problems involving maximums and minimums. These techniques solve the minimum spanning tree problem in Rk1 and Rk
579 citations
TL;DR: It is shown that two one-pass methods proposed by van Leeuwen and van der Weide are asymptotically optimal, whereas several other methods, including one proposed by Rein and advocated by Dijkstra, are slower than the best methods.
Abstract: This paper analyzes the asymptotic worst-case running time of a number of variants of the well-known method of path compression for maintaining a collection of disjoint sets under union. We show that two one-pass methods proposed by van Leeuwen and van der Weide are asymptotically optimal, whereas several other methods, including one proposed by Rein and advocated by Dijkstra, are slower than the best methods.
475 citations
TL;DR: The main result of this paper is that if the authors can draw a graph on a surface of genus g, then they can bisect it by removing $O(\sqrt{gn})$ vertices, best possible to within a constant factor.
293 citations
Proceedings Article•
01 Jan 1984
TL;DR: A general algorithmic technique which simplifies and improve computation of various functions on tress is introduced, which typically requires 0(log n) time using 0(n) space on an exclusive-read exclusive-write parallel RAM.
Abstract: In this paper we propose a new algorithm for finding the blocks (biconnected components) of an undirected graph. A serial implementation runs in O(n+m) time and space on a graph of n vertices and m edges. 4 parallel implementation runs in O(log n) time and O(n+m) space using O(n+m) processors on a concurrent-read, concurrent-write parallel RAM. An alternative implementation runs in Obn2/p3 time and O(n2) space using any number p C n /log n of processors, on a concurrent-read, exclusive-write parallel RAM. The latter algorithm has optimal speedup, assuming an adjacency matrix representation of the input. A general algorithmic technique which simplifies and improves computation of various functions on trees is introduced. This technique typically requires o(1og n) time using o(n) processors and O(n) space on an exclusive-read exclusive-write parallel RAM.
198 citations
24 Oct 1984
TL;DR: In this article, the authors propose a new algorithm for finding the blocks (biconnected components) of an undirected graph, which runs in 0[n+m] time and space on a graph of n vertices and m edges.
Abstract: We propose a new algorithm for finding the blocks (biconnected components) of an undirected graph. A serial implementation runs in 0[n+m] time and space on a graph of n vertices and m edges. A parallel implmentation runs in 0[log n] time and 0[n+m] space using 0[n+m] processors on a concurrent-read, concurrent-write parallel RAM. An alternative implementation runs in 0[n/sup 2/p] time and 0[n/sup 2/] space using any number p ⩽ n/sup 2/log/sup 2/-n of processors, on a concurrent-read, exclusive-write parallel RAM. The latter algorithm has optimal speedup, assuming an adjacency matrix representation of the input. A general algorithmic technique which simplifies and improve computation of various functions on tress is introduced. This technique typically requires 0(log n) time using 0(n) space on an exclusive-read exclusive-write parallel RAM.
177 citations
TL;DR: Consider a matroid where each element has a real-valued cost and a color, red or green; a base is sought that contains q red elements and has smallest possible cost and an algorithm for the problem on general matroids is presented, along with a number of variations.
87 citations
TL;DR: This paper proposes a simplification of Karzanov's algorithm that is easier to implement than Malhotra, Kumar and Maheshwari's method.
TL;DR: A simple linear-time algorithm that solves all three recognition problems and is previously used in general planarity testing, called a pile of twin stacks is described.
01 Dec 1984
TL;DR: The amortized complexity of two well-known algorithms used in system software, the "move-to-front" rule for maintaining an unsorted linear list representing a set, and the "least-recently-used" replacement rule for reducing page faults in a two-level paged memory are studied.
Abstract: In this paper we study the amortized complexity of two well-known algorithms used in system software, These are the "move-to-front" rule for maintaining an unsorted linear list representing a set, and the "least-recently-used" replacement rule for reducing page faults in a two-level paged memory. These algorithms have been subjected to much analysis, most of it average case. By studying the amortized complexity of these algorithms we are able to gain additional insight into their behavior.
TL;DR: The problem of determining whether a given graph is decomposable is NP-complete, which makes the existence of a polynomial-time decomposition algorithm unlikely, and the possible benefits of having an input-output decomposition may be outweighed by the difficulty of finding one.
Abstract: Pichai, Sezar, and Siljak have studied a decomposition technique for acyclic graphs, called input-output decomposition, that simplifies the analysis of dynamic systems. We show that the problem of determining whether a given graph is decomposable is NP-complete. Since this makes the existence of a polynomial-time decomposition algorithm unlikely, the possible benefits of having an input-output decomposition may be outweighed by the difficulty of finding one.
16 Jul 1984
TL;DR: A new algorithm to solve the single function coarsest partition problem in O(n) time and space using a different, constructive approach is presented.
Abstract: The problem of finding the coarsest partition of a set S with respect to another partition of S and one or more functions on S has several applications, one of which is the state minimization of finite state automata. In 1971 Hopcroft presented an algorithm to solve the many function coarsest partition problem for sets of n elements in O(n log n) time and O(n) space. Aho, Hopcroft, and Ullman later presented an algorithm that solves the special case of this problem for only one function. Both these algorithms use a negative strategy that repeatedly refines the original partition until a solution is found. We present a new algorithm to solve the single function coarsest partition problem in O(n) time and space using a different, constructive approach.