Improved Parallel Implementations of Gusfield's Cut Tree Algorithm (original) (raw)
Related papers
Parallel Implementations of Gusfield's Cut Tree Algorithm
… and Architectures for …, 2011
This paper presents parallel versions of Gusfield's cut tree algorithm. Cut trees are a compact representation of the edge-connectivity between every pair of vertices of an undirected graph. Cut trees have many applications in combinatorial optimization and in ...
A parallel implementation of Gomory-Hu's cut tree algorithm
2012
Cut trees are a compact representation of the edge-connectivity between every pair of vertices of an undirected graph, and have a large number of applications. In this work a parallel version of the well known Gomory-Hu cut tree algorithm is presented. The parallel strategy is based on the master/slave model. The strategy is optimistic in the sense that the master process manipulates the tree being constructed and the slaves solve minimum s-t-cuts independently. Another version is proposed that employs a heuristic that enumerates all (up to a limit) of the minimum s-t-cuts in order to choose the most balanced one. The algorithm was implemented and extensive experimental results are presented, including a comparison with Gusfield's cut tree algorithm. Parallel versions of these algorithms have achieved significant speedups on real and synthetic graphs. We discuss the trade-offs between the two alternatives, each of which presents better results given the characteristics of the input graph. In particular, the existence of balanced cuts clearly gives an advantage to Gomory-Hu's algorithm.
Tree-based graph algorithms for some parallel computers
This paper gives several optimal mesh computer, VLSI, and pyramid computer algorithms for determining properties of an arbitrary undirected graph, where the graph is given as an unordered collection of edges. The algorithms first find spanning trees and then use them to determine properties of the graph. By using edges, instead of requiring an entire adjacency matrix, these algorithms use only ¢ ½ ¾ ¡ time on a 2-dimensional mesh, instead of the ª´Úµ time required with matrix input. Further, the edge-based algorithms extend naturally to meshes of arbitrary dimension , finishing in ¢ ½ ¡ time. All of the times are optimal, and the algorithms extend to VLSI and pyramid models.
Graph algorithms on a tree-structured parallel computer
BIT, 1984
Parallel algorithms for some graph-theoretic problems on a tree-structured computer are presented. In particular, if p denotes the number of processing elements, algorithms that run in O(nZ/p) time for finding connected components, transitive closure and the minimum spanning tree of an undirected graph with n vertices are obtained.
A parallel algorithm for bisection width in trees
Computers & Mathematics with Applications, 1988
The bisection width b(G) of a graph G is the number of edges necessary in an edge cut of G so that the two sides of the cut have equal (within one element) size. Our main result is an O(n 2) processor O(log2n loglogn) time parallel algorithm for determining b(T) when T is a tree. centroid of T itself, so the reduction used by MacGregor cannot be performed. In order to overcome this difficulty, we change the set of subtrees used for the reduction and generalize the problem.
Foundations of Computer Science, 1984
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.
A coarse-grained parallel algorithm for spanning tree and connected components
2004
Dehne et al. present a BSP/CGM algorithm for computing a spanning tree and the connected components of a graph, that requires O(log p) communication rounds, where p is the number of processors. It requires the solution of the Euler tour problem which in turn is based on the solution of the list ranking problem. In this paper we present experimental results of a parallel algorithm that does not depend on the solution of the Euler tour or the list ranking problem. The proposed algorithm has the practical advantage of avoiding the list ranking computation and is based on the integer sorting algorithm which can be implemented efficiently on the BSP/CGM model. We implemented the proposed algorithm on a Beowulf cluster and on a grid running the InteGrade middleware. We obtained encouraging albeit modest speedup on a small Beowulf cluster and expect good speedups on the grid for larger size graphs and clusters.
Efficient Parallel Algorithms for a Class of Graph Theoretic Problems
SIAM Journal on Computing, 1984
In this paper, we present efficient parallel algorithms for the following graph problems: finding the lowest common ancestors for vertex pairs of a directed tree; finding all fundamental cycles, a directed spanning forest, all bridges, all bridge-connected components, all separation vertices, all biconnected components, and testing the biconnectivity of an undirected graph. All these algorithms achieve the O(lg n) time bound, with the first two algorithms using n[n/lg n] processors and the remaining algorithms using n[n/lg n] processors. In all cases, our algorithms are better than the previously known algorithms and in most cases reduce the number of processors used by a factor of n lg n. Moreover, our algorithms are optimal with respect to the time-processor product for dense graphs, with the exception of the first two algorithms. The machine model we use is the PRAM which is a SIMD model allowing simultaneous reads but not simultaneous writes to the same memory location.
A Survey on Methods for finding Min-Cut Tree
International Journal of Computer Applications, 2013
In this paper we have discussed all existing approaches to solve the problem for calculating the min-cut tree of an undirected edge-weighted graph and present a new approximation algorithm for constructing the minimum-cut tree. We discussed Gomory-Hu algorithm. The algorithm proposed by Gomory and Hu has time complexity O(V*time complexity of finding a min s-t cut). We also have discussed Ford-Fulkerson method. Running time of Ford-Fulkerson algorithm is O(ve 2). The asymptotically fastest maximumflow algorithms are based on push-relabel method and have the running time of O(V 3). M. Stoer and F. Wagner have given a simple and compact algorithm for finding the minimum cut of a graph. The algorithm is remarkably simple and has the fastest running time so far the algorithm consists of |V|-1 identical phases each of which requires O(|e| + |V| log |V|) time yielding an overall running time of O(|V||e| + log |V|). We present a new approximation algorithm for constructing the minimum cut tree. We calculate an upperbound value for each node in the graph. We define the upper bound value of each node as the value of cut which separates this node from rest of the graph and our algorithm runs in O(V 2 .logV + V 2 .d), where V is the number of vertices in the given graph and d is the degree of the graph. It is a significant improvement over time complexities of existing solutions. However, because of an assumption it does not produce correct result for all sorts of graphs but for the dense graphs success rate is more than 90%. Moreover in the unsuccessful cases, the deviation from actual result is very less (usually for less than 5% pairs) and for most of the pairs we obtain correct values of max-flow or min-cut.
Efficient parallel algorithms for graph problems
Algorithmica, 1990
In this thesis we examine three problems in graph theory and propose e cient parallel algorithms for solving them. We also introduce a number of parallel algorithmic techniques.