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].

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 P-complete problems (evaluating straight-line 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...

A randomized (Las Vegas) algorithm is given for finding the Gallai–Edmonds decomposition of a graph. Let n denote the number of vertices, and let M(n) denote the number of arithmetic operations for multiplying two n × n matrices. The sequential running time (i.e., number of bit operations) is within a poly-logarithmic factor of M(n). The parallel complexity is O((log n) 2) parallel time using a number of processors within a poly-logarithmic factor of M(n). The same complexity bounds suffice for solving several other problems: (i) finding a minimum vertex cover in a bipartite graph, (ii) finding a minimum X→Y vertex separator in a directed graph, where X and Y are specified sets of vertices, (iii) finding the allowed edges (i.e., edges that occur in some maximum matching) of a graph, and (iv) finding the canonical partition of the vertex set of an elementary graph. The sequential algorithms for problems (i), (ii), and (iv) are Las Vegas, and the algorithm for problem (iii) is Monte Carlo. The new complexity bounds are significantly better than the best previous ones, e.g., using the best value of M(n) currently known, the new sequential running time is O(n2.38) versus the previous best O(n2.5 /(log n)) or more.

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...

We present new algebraic approaches for two well-known combinatorial problems: non-bipartite matching and matroid intersection. Our work yields new randomized algorithms that exceed or match the efficiency of existing algorithms. For nonbipartite matching, we obtain a simple, purely algebraic algorithm with running time O(n ω) where n is the number of vertices and ω is the matrix multiplication exponent. This resolves the central open problem of Mucha and Sankowski (2004). For matroid intersection, our algorithm has running time O(nr ω−1) for matroids with n elements and rank r that satisfy some natural conditions.

revised Version Abstract. We present an NC approximation algorithm for the weighted matching problem in graphs with an approximation ratio of (1 − ɛ). This improves the previously best approximation ratio of − ɛ) of an NC algorithm for this problem. ( 1 2

There are many fields of algorithms design where probabilistic methods and randomization lead to appreciable gains. In fact, randomness has emerged as a fundamental tool in the design and analysis of algorithms. It is substantially easier to obtain algorithms for many problems if we allow the use of randomness as a resource. This has been demonstrated for parallel algorithms as well. In this chapter, we highlight some fundamental randomization techniques and also discuss the class RNC of problems efficiently solved by probabilistic parallel algorithms. 1. Randomized Parallel Algorithms and the class RNC What does efficiency mean for a parallel algorithm? Roughly, we mean that it runs fast and uses not-too-many processors. This has been crystallized in the theoretical community in the notion of the complexity class NC, i.e. the class 1 of algorithms running in polylogarithmic (in the length of the input) time with polynomially many processors. Similarly, RNC (Randomized NC) is the cl...

A randomized (Las Vegas) algorithm is given for finding the Gallai-Edmonds decomposition of a graph. Let n denote the number of vertices, and let M(n) denote the number of arithmetic operations for multiplying two nn matrices. The sequential running time (i.e., number of bit operations) is within a poly-logarithmic factor of M(n). The parallel complexity is O((log n) 2 ) parallel time using a number of processors within a poly-logarithmic factor of M(n). The same complexity bounds suffice for solving several other problems: (i) finding a minimum vertex cover in a bipartite graph, (ii) finding a minimum X#Y vertex separator in a directed graph, where X and Y are specified sets of vertices, (iii) finding the allowed edges (i.e., edges that occur in some maximum matching) of a graph, and (iv) finding the canonical partition of the vertex set of an elementary graph. The sequential algorithms for problems (i), (ii), and (iv) are Las Vegas, and the algorithm for problem (iii) is Monte Car...

We present a randomized NC solution to the problem of constructing a maximum (cardinality) f-matching. As a corollary, we obtain a randomized NC algorithm for the problem of constructing a graph satisfying a sequence d 1 ; d 2 ;...; d n of equality degree constraints. We provide an optimal NC algorithm for the decision version of the degree sequence problem and an approximation NC algorithm for the construction version of this problem. Our main result is an NC algorithm for constructing if possible a graph satisfying the degree constraints d 1 ; d 2 ;...; d n in case d i q P n j=1 d j =5 for i = 1; :::; n: 1 Introduction Finding a maximum (cardinality) matching in a graph is a fundamental problem in combinatorial optimization. It is a major open problem whether a maximum matching can be constructed by an NC algorithm. Achieving simultaneously a polylog-time and a polynomial number of processors is possible for this problem if random bits are used. Randomized NC algorithms ...