Abstract. Currently, there is a significant gap between the best sequential and parallel complexities of many fundamental problems related to digraph reachability. This complexity bottleneck essentially reflects a seemingly unavoidable reliance on transitive closure techniques in parallel algorithms for digraph reachability. To pinpoint the nature of the bottleneck, we de* velop a collection of polylog-time reductions among reachability problems. These reductions use only linear processors and work for general graphs. Furthermore, for planar digraphs, we give polylog-time algorithms for the following problems: (1) directed ear decomposition, (2) topological ordering, (3) digraph reachability, (4) descendent counting, and (5) depth-first search. These algorithms use only linear processors and therefore reduce the complexity to within a polylog factor of optimal.

We present a randomized algorithm for finding maximum matchings in planar graphs in time O(n ω/2), where ω is the exponent of the best known matrix multiplication algorithm. Since ω < 2.38, this algorithm breaks through the O(n 1.5) barrier for the matching problem. This is the first result of this kind for general planar graphs. We also present an algorithm for generating perfect matchings in planar graphs uniformly at random using O(n ω/2) arithmetic operations. Our algorithms are based on the Gaussian elimination approach to maximum matchings introduced in [1].

We show how to decompose efficiently in parallel any graph into a number, ~ fl, of outerplanar subgraphs (called hammocks) satisfying certain separator properties. Our work combines and extends the sequential hammock decomposition technique introduced by G. Frederickson and the parallel ear decomposition technique, thus we call it the hammock-on-ears decomposition. We mention that hammock-on-ears decomposition also draws from techniques in computational geometry and that an embedding of the graph does not need to be provided with the input. We achieve this decomposition in O(logn log log n) time using O(n + m) CREW PRAM processors, for an n-vertex, m-edge graph or digraph. The hammock-on-ears decomposition implies a general framework for solving graph problems efficiently. Its value is demonstrated by a variety of applications on a significant class of (di)graphs, namely that of sparse (di)graphs. This class consists of all (di)graphs which have a ~ fl between 1 and \Theta(n...

It has been known for a long time now that the problem of counting the number of perfect matchings in a planar graph is in NC. This result is based on the notion of a pfaffian orientation of a graph. (Recently, Galluccio and Loebl [7] gave a P-time algorithm for the case of graphs of small genus.) However, it is not known if the corresponding search problem, that of finding one perfect matching in a planar graph, is in NC. This situation is intriguing as it seems to contradict our intuition that search should be easier than counting. For the case of planar bipartite graphs, Miller and Naor [22] showed that a perfect matching can indeed be found using an NC algorithm. We present a very different NC-algorithm for this problem. Unlike the Miller...

We observe that the classical maximum flow problem in any directed planar graph G can be reformulated as a parametric shortest path problem in the oriented dual graph G ∗. This reformulation immediately suggests an algorithm to compute maximum flows, which runs in O(n log n) time. As we continuously increase the parameter, each change in the shortest path tree can be effected in O(log n) time using standard dynamic tree data structures, and the special structure of the parametrization implies that each directed edge enters the evolving shortest path tree at most once. The resulting maximum-flow algorithm is identical to the recent algorithm of Borradaile and Klein [J. ACM 2009], but our new formulation allows a simpler presentation and analysis. On the other hand, we demonstrate that for a similarly structured parametric shortest path problem on the torus, the shortest path tree can change Ω(n²) times in the worst case, suggesting that a different method may be required to efficiently compute maximum flows in higher-genus graphs.

We study the edge-disjoint escape problem in grids. Given a set of n sources in a two-dimensional grid, the problem is to connect all sources to the grid boundary using a set of n edge-disjoint paths. Different from the conventional approach, which reduces the problem to a network flow problem, we solve the problem by first ensuring that no rectangle in the grid contain more sources than outlets, a necessary and sufficient condition for the existence of a solution. Based on this condition, we give a greedy algorithm that finds the paths in O(n 2) time, which is faster than all previous approaches. This problem finds applications in point-to-point delivery, VLSI reconfiguration, and package routing. 1

In this paper we present algorithms for computing large matchings in 3-regular graphs, graphs with maximum degree 3, and 3-connected planar graphs. The algorithms give a guarantee on the size of the computed matching and take linear or slightly superlinear time. Thus they are faster than the best-known algorithm for computing maximum matchings in general graphs, which runs in O ( √ nm) time, where n denotes the number of vertices and m the number of edges of the given graph. For the classes of 3-regular graphs and graphs with maximum degree 3 the bounds we achieve are known to be best possible. We also investigate graphs with block trees of bounded degree, where the d-block tree is the adjacency graph of the d-connected components of the given graph. In 3-regular graphs and 3-connected planar graphs with bounded-degree 2- and 4-block trees, respectively, we show how to compute maximum matchings in slightly superlinear time.

We consider the problem of finding the minimum cost of a feasible flow in directed series-parallel networks. We allow real-valued lower and upper bounds for the flows on edges. While strongly polynomial-time algorithms are known for this problem on arbitrary networks, it is known to be "hard" for parallelization. We develop, for the first time, an efficient NC algorithm to solve the min-cost flow problem on directed seriesparallel networks partially solving a problem posed by Booth and Tarjan [6, 5]. Our algorithm takes O(log 2 m) time using O(m= log m) processors on an EREW PRAM and it is optimal with respect to Booth and Tarjan's algorithm with running time O(m log m). The algorithm owes it's efficiency to the tree contraction technique and using simple data structures for flow list manipulations as opposed to finger search trees. 1 Introduction Let G = (V; E) be a directed network with two distinguished vertices s and t called the source and the sink respectively. For each e = ...

Abstract. For planar graphs, counting the number of perfect matchings (and hence determining whether there exists a perfect matching) can be done in NC [4, 10]. For planar bipartite graphs, finding a perfect matching when one exists can also be done in NC [8, 7]. However in general planar graphs (when the bipartite condition is removed), no NC algorithm for constructing a perfect matching is known. We address a relaxation of this problem. We consider the fractional matching polytope P(G) of a planar graph G. Each vertex of this polytope is either a perfect matching, or a half-integral solution: an assignment of weights from the set {0, 1/2, 1} to each edge of G so that the weights of edges incident on each vertex of G add up to 1 [6]. We show that a vertex of this polytope can be found in NC, provided G has at least one perfect matching to begin with. If, furthermore, the graph is bipartite, then all vertices are integral, and thus our procedure actually finds a perfect matching without explicitly exploiting the bipartiteness of G. 1

We give an O(n 1.5 log n) algorithm that, given a directed planar graph with arc capacities, a set of source nodes and a single sink node, finds a maximum flow from the sources to the sink. This is the first subquadratictime strongly polynomial algorithm for the problem. 1