Results 1  10
of
31
Network Decomposition and Locality in Distributed Computation (Extended Abstract)
, 1989
"... ) Baruch Awerbuch Department of Mathematics and Laboratory for Computer Science M.I.T. Cambridge, MA 02139 Andrew V. Goldberg y Department of Computer Science Stanford University Stanford, CA 94305 Michael Luby z International Computer Science Institute Berkeley, CA 94704 Serge A. Plo ..."
Abstract

Cited by 79 (5 self)
 Add to MetaCart
) Baruch Awerbuch Department of Mathematics and Laboratory for Computer Science M.I.T. Cambridge, MA 02139 Andrew V. Goldberg y Department of Computer Science Stanford University Stanford, CA 94305 Michael Luby z International Computer Science Institute Berkeley, CA 94704 Serge A. Plotkin x Department of Computer Science Stanford University Stanford, CA 94305 May 1989 Abstract We introduce a concept of network decomposition, the essence of which is to partition an arbitrary graph into smalldiameter connected components, such that the graph created by contracting each component into a single node has low chromatic number. We present an efficient distributed algorithm for constructing such a decomposition, and demonstrate its use for design of efficient distributed algorithms. Our method yields new deterministic distributed algorithms for finding a maximal independent set and for (\Delta + 1)coloring of graphs with maximum degree \Delta. These algorithms run...
Parallel SymmetryBreaking in Sparse Graphs
 SIAM J. Disc. Math
, 1987
"... We describe efficient deterministic techniques for breaking symmetry in parallel. These techniques work well on rooted trees and graphs of constant degree or genus. Our primary technique allows us to 3color a rooted tree in O(lg n) time on an EREW PRAM using a linear number of processors. We use th ..."
Abstract

Cited by 69 (2 self)
 Add to MetaCart
We describe efficient deterministic techniques for breaking symmetry in parallel. These techniques work well on rooted trees and graphs of constant degree or genus. Our primary technique allows us to 3color a rooted tree in O(lg n) time on an EREW PRAM using a linear number of processors. We use these techniques to construct fast linear processor algorithms for several problems, including (\Delta + 1)coloring constantdegree graphs and 5coloring planar graphs. We also prove lower bounds for 2coloring directed lists and for finding maximal independent sets in arbitrary graphs. 1 Introduction Some problems for which trivial sequential algorithms exist appear to be much harder to solve in a parallel framework. When converting a sequential algorithm to a parallel one, at each step of the parallel algorithm we have to choose a set of operations which may be executed in parallel. Often, we have to choose these operations from a large set A preliminary version of this paper appear...
Removing Randomness in Parallel Computation Without a Processor Penalty
 Journal of Computer and System Sciences
, 1988
"... We develop some general techniques for converting randomized parallel algorithms into deterministic parallel algorithms without a blowup in the number of processors. One of the requirements for the application of these techniques is that the analysis of the randomized algorithm uses only pairwise in ..."
Abstract

Cited by 48 (1 self)
 Add to MetaCart
We develop some general techniques for converting randomized parallel algorithms into deterministic parallel algorithms without a blowup in the number of processors. One of the requirements for the application of these techniques is that the analysis of the randomized algorithm uses only pairwise independence. Our main new result is a parallel algorithm for coloring the vertices of an undirected graph using at most \Delta + 1 distinct colors in such a way that no two adjacent vertices receive the same color, where \Delta is the maximum degree of any vertex in the graph. The running time of the algorithm is O(log 3 n log log n) using a linear number of processors on a concurrent read, exclusive write (CREW) parallel random access machine (PRAM). 1 Our techniques also apply to several other problems, including the maximal independent set problem and the maximal matching problem. The application of the general technique to these last two problems is mostly of academic interest because...
A Simple Approximation Algorithm for the Weighted Matching Problem
 Information Processing Letters
, 2003
"... We present a linear time approximation algorithm with a performance ratio of 1/2 for nding a maximum weight matching in an arbitrary graph. Such a result is already known and is due to Preis [7]. ..."
Abstract

Cited by 28 (3 self)
 Add to MetaCart
We present a linear time approximation algorithm with a performance ratio of 1/2 for nding a maximum weight matching in an arbitrary graph. Such a result is already known and is due to Preis [7].
Constructing a Maximal Independent Set in Parallel
 SIAM J. Disc. Math
, 1989
"... f a The problem of constructing in parallel a maximal independent set o given graph is considered. A new deterministic NC algorithm imple  t mented in the EREW PRAM model is presented. On graphs with n ver ices and m edges, it uses O ((n +m )/logn ) processors and runs in O (log n ) 3  c time. T ..."
Abstract

Cited by 21 (1 self)
 Add to MetaCart
f a The problem of constructing in parallel a maximal independent set o given graph is considered. A new deterministic NC algorithm imple  t mented in the EREW PRAM model is presented. On graphs with n ver ices and m edges, it uses O ((n +m )/logn ) processors and runs in O (log n ) 3  c time. This reduces by a factor of logn both the running time and the pro essor count of the previously fastest deterministic algorithm which solves the problem using a linear number of processors. Key words: parallel computation, NC, graph, maximal independent set, 1 deterministic. . Introduction The problem of constructing in parallel a maximal independent set of a given graph, t MIS , has been investigated in several recent papers. Karp and Wigderson proved in [KW] hat the problem is in NC . Their algorithm finds a maximal independent set of an n  vertex graph in O (log n ) time and uses O (n /log n ) processors. In successive papers, the 4 3 3  s authors proposed algorithms which either...
An efficient incremental algorithm for generating all maximal independent sets in hypergraphs of bounded dimension
 Parallel Processing Letters
, 2000
"... We show that for hypergraphs of bounded edge size, the problem of extending a given list of maximal independent sets is NCreducible to the computation of an arbitrary maximal independent set for an induced subhypergraph. The latter problem is known to be in RNC. In particular, our reduction yields ..."
Abstract

Cited by 16 (9 self)
 Add to MetaCart
We show that for hypergraphs of bounded edge size, the problem of extending a given list of maximal independent sets is NCreducible to the computation of an arbitrary maximal independent set for an induced subhypergraph. The latter problem is known to be in RNC. In particular, our reduction yields an incremental RNC dualization algorithm for hypergraphs of bounded edge size, a problem previously known to be solvable in polynomial incremental time. We also give a similar parallel algorithm for the dualization problem on the product of arbitrary lattices which have a bounded number of immediate predecessors for each element. 1
Designing Checkers for Programs that Run in Parallel
 Algorithmica
, 1994
"... Program correctness for parallel programs is an even more problematic issue than for serial programs. We extend the theory of program result checking to parallel programs, and find general techniques for designing such result checkers that work for many basic problems in parallel computation. These ..."
Abstract

Cited by 13 (2 self)
 Add to MetaCart
Program correctness for parallel programs is an even more problematic issue than for serial programs. We extend the theory of program result checking to parallel programs, and find general techniques for designing such result checkers that work for many basic problems in parallel computation. These result checkers are simple to program and are more efficient than the actual computation of the result. For example, sorting, multiplication, parity, the all pairs shortest path problem and majority all have constant depth result checkers, and the result checkers for all but the last problem use a linear number of processors. We show that there are Pcomplete problems (evaluating straightline programs, linear programming) that have very fast, even constant depth, result checkers. 1 Introduction Verifying a program to see if it is correct is a problem that every programmer has encountered. Even the seemingly simplest of programs can be full of hidden bugs, and in the age of massive software...
Computing Minimal Spanning Subgraphs in Linear Time
, 1995
"... Let P be a property of undirected graphs. We consider the following problem: given a graph G that has property P , find a minimal spanning subgraph of G with property P . We describe general algorithms for this problem and prove their correctness under fairly weak assumptions about P . We establi ..."
Abstract

Cited by 10 (1 self)
 Add to MetaCart
Let P be a property of undirected graphs. We consider the following problem: given a graph G that has property P , find a minimal spanning subgraph of G with property P . We describe general algorithms for this problem and prove their correctness under fairly weak assumptions about P . We establish that the worstcase running time of these algorithms is \Theta(m +n log n) for 2edgeconnectivity and biconnectivity where n and m denote the number of vertices and edges, respectively, in the input graph. By refining the basic algorithms we obtain the first linear time algorithms for computing a minimal 2edgeconnected spanning subgraph and for computing a minimal biconnected spanning subgraph. We also devise general algorithms for computing a minimal spanning subgraph in directed graphs. These algorithms allow us to simplify an earlier algorithm of Gibbons, Karp, Ramachandran, Soroker and Tarjan for computing a minimal strongly connected spanning subgraph. We also provide the ...
An Efficient Parallel Algorithm That Finds Independent Sets Of Guaranteed Size
, 1990
"... . Every graph with n vertices and m edges has an independent set containing at least n 2 =(2m +n) vertices. We present a parallel algorithm that nds an independent set of this size and runs in O(log 3 n) time on a CRCW PRAM with O((m + n)(m; n)= log 2 n) processors, where (n; m) is a functiona ..."
Abstract

Cited by 10 (0 self)
 Add to MetaCart
. Every graph with n vertices and m edges has an independent set containing at least n 2 =(2m +n) vertices. We present a parallel algorithm that nds an independent set of this size and runs in O(log 3 n) time on a CRCW PRAM with O((m + n)(m; n)= log 2 n) processors, where (n; m) is a functional inverse of Ackerman's function. The ideas used in the design of this algorithm are also used to design an algorithm that, with the same resources, nds a vertex coloring satisfying certain minimality conditions. Key words. Turan's theorem, independent set, NC, graph, parallel computation, deterministic AMS(MOS) subject classications. 68Q22, 68R10, 68R05 1. Introduction. This paper presents a fast parallel algorithm that, given a graph G, nds an independent set of G whose size is bounded from below. The bound depends on the number n of vertices and number m of edges of G, and cannot be improved in these terms. Since constructing a maximum independent set is NPhard, it cannot be so...
On the parallel complexity of Hamiltonian Cycle and Matching Problem on Dense Graphs
 Journal of Algorithms
, 1993
"... Dirac's classical theorem asserts that, if every vertex of a graph G on n vertices has degree at least n 2 then G has a Hamiltonian cycle. We give a fast parallel algorithm on a CREW \Gamma PRAM to find a Hamiltonian cycle in such graphs. Our algorithm uses a linear number of processors and is o ..."
Abstract

Cited by 10 (1 self)
 Add to MetaCart
Dirac's classical theorem asserts that, if every vertex of a graph G on n vertices has degree at least n 2 then G has a Hamiltonian cycle. We give a fast parallel algorithm on a CREW \Gamma PRAM to find a Hamiltonian cycle in such graphs. Our algorithm uses a linear number of processors and is optimal up to a polylogarithmic factor. The algorithm works in O(log 4 n) parallel time and uses linear number of processors on a CREW \Gamma PRAM . Our method bears some resemblance to Anderson's RNC algorithm [An] for maximal paths: we, too, start from a system of disjoint paths and try to glue them together. We are, however, able to perform the base step (perfect matching) deterministically. We also prove that a perfect matching in dense graphs can be found in NC 2 . The cost of improved time is a quadratic number of processors. On the negative side, we prove that finding an NC algorithm for perfect matching in slightly less dense graphs (minimum degree is at least ( 1 2 \Gamma ff...