Efficient parallel algorithms for series parallel graphs
TL;DR: A parallel algorithm for recognizing series parallel graphs and constructing decomposition trees and takes O(log2 n + log m) time with O(n + m) processors, where n (m) is the number of vertices (edges) in the graph.
About: This article is published in Journal of Algorithms.The article was published on 1991-09-01. It has received 30 citations till now. The article focuses on the topics: Spanning tree & Time complexity.
Citations
More filters
TL;DR: An optimal parallel algorithm for computing a cycle separator of ann-vertex embedded planar undirected graph in O(logn) time on n/logn processors is presented and an improved parallel algorithm is obtained for constructing a depth-first search tree rooted at any given vertex in a connected planar Undirectedgraph.
Abstract: We present an optimal parallel algorithm for computing a cycle separator of ann-vertex embedded planar undirected graph inO(logn) time onn/logn processors. As a consequence, we also obtain an improved parallel algorithm for constructing a depth-first search tree rooted at any given vertex in a connected planar undirected graph in O(log2n) time on n/logn processors. The best previous algorithms for computing depth-first search trees and cycle separators achieved the same time complexities, but withn processors. Our algorithms run on a parallel random access machine that permits concurrent reads and concurrent writes in its shared memory and allows an arbitrary processor to succeed in case of a write conflict.
5 citations
Cites methods from "Efficient parallel algorithms for s..."
...For unordered depth-first search, while randomized NC algorithms have been found for general graphs [2], [3], deterministic algorithms are known only for certain classes of graphs, including chordal graphs [26], series parallel graphs [19], planar undirected graphs [16], [20], [21], [36], and directed planar graphs [22]-[24]....
[...]
TL;DR: A parallel algorithm for computing K-terminal reliability, denoted byR(GK), in 2-trees using a method that transforms, in parallel, a given partial 2- tree into a 2-tree.
5 citations
01 Jan 1998
TL;DR: The project of proof animation, which started last April, and the motivations, aims, and problems of the proof animation will be presented, and a demo of ProofWorks, a small prototype tool for proof animation.
Abstract: We will present the project of proof animation, which started last April. The motivations, aims, and problems of the proof animation will be presented. We will also make a demo of ProofWorks, a small prototype tool for proof animation. Proof animation means to execute formal proofs to find incorrectness in them. A methodology of executing formal proofs as programs is known as “proofs as programs” or “constructive programming.” “Proofs as programs” is a means to exclude incorrectness from programs by the aid of formal proof checking. Although proof animation resembles proof as programs and in fact it is a contrapositive of proofs as programs, it seems to provide an entirely new area of research of proof construction. In spite of wide suspicions and criticisms, formal proof developments are becoming a reality. We have already had some large formal proofs like Shanker’s proof of Gödel’s incompleteness theorem and proof libraries of mathematics and computer science are being built by some teams aided by advanced proof checkers such as Coq, HOL, Mizar, etc. However, construction of big formal proofs is still very costly. The construction of formal proofs are achieved only through dedicated labors by human beings. Formal proof developments are much more time-consuming and so costly activities than program developments. Why is it so? A reason would be lack of means of testing proofs. Testing programs by examples is less reliable than verifying programs formally. It is practically impossible to exclude all bugs of complicated software only by testing. Verification is superior to testing for achieving “pure-water correctness,” a correctness at the degree of purity of pure water. However, testing is much easier and more efficient to find 80% or 90% of bugs in programs. Since the majority of softwares need correctness only at the degree ? Supported by No. 10480063, Monbusyo, Kaken-hi (the aid of Scientific Research, The Ministry of Education) Jieh Hsiang, Atsushi Ohori (Eds.): ASIAN’98, LNCS 1538, pp. 1–3, 1998. c © Springer-Verlag Berlin Heidelberg 1998 2 Susumu Hayashi and Ryosuke Sumitomo of purity of tap water, the most standard way of debugging is still testing rather than verification. Furthermore, the majority of people seem to find that testing programs is more enjoyable than verification. For software developments, we have two options. However, we have only one option for formal proof developments. Obviously checking formal proofs by formal inference rules corresponds to verification. (In fact, the activity of verifications is a “subset” of formal proofs by formal proof checking.) Thus, we may set an equation
5 citations
Cites background or methods from "Efficient parallel algorithms for s..."
...When we claim fault-tolerance for a given implementation Impl relative to a fault assumption Faults and a specification Spec, we only proceed to prove correctness of an implementation T (Impl, Faults) which represents syntactically how Impl behaves in the presence of Faults [15,16,8]; this reduction is most common without introducing the transformation T explicitly [4,2,12,22,18,19,21,14,1,23]....
[...]
...Implementations of arithmetic functions such as the square root are based on much larger lookup tables [15,16,17] and many of these implementations use multiple lookup tables[15,16]....
[...]
...We are now working for the draft[16] to show the precise relation between them....
[...]
...Only the recursive linear hashing [16] proposed by Ramamohanarao and Sacks uses a predetermined number of linear hashing files to organize the overflow blocks....
[...]
11 Aug 1993
TL;DR: An improved parallel algorithm for constructing a depth-first search tree in a connected undirected planar graph in O(log2n) time with n/log n processors for an n-vertex graph is presented.
Abstract: We present an improved parallel algorithm for constructing a depth-first search tree in a connected undirected planar graph. The algorithm runs in O(log2n) time with n/log n processors for an n-vertex graph. It hinges on the use of a new optimal algorithm for computing a cycle separator of an embedded planar graph in O(log n) time with n/log n processors. The best previous algorithms for computing depth-first search trees and cycle separators achieved the same time complexities, but with n processors. Our algorithms run on a parallel random access machine that permits concurrent reads and concurrent writes in its shared memory and allows an arbitrary processor to succeed in case of a write conflict.
4 citations
Cites methods from "Efficient parallel algorithms for s..."
...For unordered depthfirst search, while randomized NC algorithms have been found for general graphs [2, 3], deterministic algorithms are known only for certain classes of graphs, including chordal graphs [26], series parallel graphs [ 19 ], undirected planar graphs [16, 20, 21, 34], and directed planar graphs [22, 23, 24]....
[...]
11 Aug 2006
TL;DR: This paper shows how the tree contraction method can be applied to compute the cardinality of the minimum vertex cover of a two-terminal series-parallel graph and shows that in the new computational environment, a parallel algorithm is superior to the best possible sequential algorithm, in terms of the accuracy of the solution computed.
Abstract: In this paper we show how the tree contraction method can be applied to compute the cardinality of the minimum vertex cover of a two-terminal series-parallel graph. We then construct a real-time paradigm for this problem and show that in the new computational environment, a parallel algorithm is superior to the best possible sequential algorithm, in terms of the accuracy of the solution computed. Specifically, there are cases in which the solution produced by a parallel algorithm that uses p processors is better than the output of any sequential algorithm for the same problem, by a factor superlinear in p.
3 citations
References
More filters
Book•
01 Jan 1974
TL;DR: This text introduces the basic data structures and programming techniques often used in efficient algorithms, and covers use of lists, push-down stacks, queues, trees, and graphs.
Abstract: From the Publisher:
With this text, you gain an understanding of the fundamental concepts of algorithms, the very heart of computer science. It introduces the basic data structures and programming techniques often used in efficient algorithms. Covers use of lists, push-down stacks, queues, trees, and graphs. Later chapters go into sorting, searching and graphing algorithms, the string-matching algorithms, and the Schonhage-Strassen integer-multiplication algorithm. Provides numerous graded exercises at the end of each chapter.
0201000296B04062001
9,262 citations
Book•
01 Jan 1976
TL;DR: In this paper, the authors present Graph Theory with Applications: Graph theory with applications, a collection of applications of graph theory in the field of Operational Research and Management. Journal of the Operational research Society: Vol. 28, Volume 28, issue 1, pp. 237-238.
Abstract: (1977). Graph Theory with Applications. Journal of the Operational Research Society: Vol. 28, Volume 28, issue 1, pp. 237-238.
7,497 citations
5,837 citations
IBM1
TL;DR: A new method for accelerating matrix multiplication asymptotically is presented, by using a basic trilinear form which is not a matrix product, and making novel use of the Salem-Spencer Theorem.
Abstract: We present a new method for accelerating matrix multiplication asymptotically. This work builds on recent ideas of Volker Strassen, by using a basic trilinear form which is not a matrix product. We make novel use of the Salem-Spencer Theorem, which gives a fairly dense set of integers with no three-term arithmetic progression. Our resulting matrix exponent is 2.376.
1,413 citations
TL;DR: A linear-time algorithm to recognize the class of vertex series-parallel (VSP) digraphs is presented and efficient methods to compute the transitive closure and transitive reduction of VSPDigraphs are obtained.
Abstract: We present a linear-time algorithm to recognize the class of vertex series-parallel (VSP) digraphs. Our method is based on the relationship between VSP digraphs and the class of edge series-paralle...
564 citations