NC Algorithm Research Articles

Linear-Processor NC Algorithms for Planar Directed Graphs I: Strongly Connected Components

Finding strongly connected components is a fundamental step in many algorithms for directed graphs. In sequential computation this problem has an optimal linear-time algorithm. In parallel computation, however, it remains an open problem whether polylogarithmic time and a linear number of processors are sufficient for computing the strongly connected components on a parallel random-access machine. This paper provides the first nontrivial partial solution to the open problem: for a planar directed graph of size n the strongly connected components can be computed deterministically in $O(\log ^3 n)$ time with ${n / {\log n}}$ processors. The algorithm runs on a parallel random-access machine that allows concurrent reads and concurrent writes in its shared memory and, in case of a write conflict, permits an arbitrary processor to succeed.

Linear-Processor NC Algorithms for Planar Directed Graphs II: Directed Spanning Trees

It has long been a fundamental open problem whether polylog time and {\em linear} processors are sufficient to find the strongly connected components of a directed graph and compute directed spanning trees for these components. This paper provides the first nontrivial partial solution to the tree problem: for a planar directed graph with $n$ vertices, if the graph is strongly connected, then a directed spanning tree rooted at a specified vertex can be built in $0(log^2~n)$ time using $0(n)$ processors. The algorithm is deterministic and runs on a parallel random access machine that allows concurrent reads and concurrent writes in its shared memory. The result complements an algorithm by Kao that computes the strongly connected components of a planar directed graph in $0(log^3~n)$ time and $0(n)$ processors.

Factoring Rational Polynomials over the Complex Numbers

NC algorithms are given for determining the number and degrees of the factors, irreducible over the complex numbers ${\bf C}$, of a multivariate polynomial with rational coefficients and for approximating each irreducible factor. NC is the class of functions computable by logspace-uniform boolean circuits of polynomial size and polylogarithmic depth. The measures of size of the input polynomial are its degree, coefficient length, number of variables (d, c, and n, respectively). If n is fixed, we give a deterministic NC algorithm. If the number of variables is not fixed, we give a random (Monte-Carlo) NC algorithm in these input measures to find the number and degree of each irreducible factor. After reducing to the two-variable, square-free case, we apply the classical algebraic geometry fact that the absolute irreducible factors of $(P(z_1 ,z_2 ) = 0)$ correspond to the connected components of the real surface (or complex curve) $P(z_1 ,z_2 ) = 0$ minus its singular points. In finding the number of connected components of the surface $P = 0$, the surface is projected to the the $z_2 $-plane. The singular points of $P(z_1 ,z_2 )$ lie over the projection’s critical values. The inverse image of a grid isolating the critical values in the $z_2 $-plane lifts to a one-dimensional real curve skeleton on the surface $(P = 0)$ whose number of connected components is precisely the number of connected components of $P = 0$ minus its singular points. The connectivity of this curve skeleton is constructed symbolically using Sturm sequences associated with the various polynomials defining these maps. Given the number of irreducible factors and their degrees, the actual factors can be reconstructed using the recent result of Neff [Proceedings of the 31st Annual Symposium on Foundations of Computer Science, pp. 152–162] on finding zeros of one-variable polynomials in NC.

An efficient parallel algorithm for computing a maximal independent set in a hypergraph of dimension 3

This paper considers the problem of computing a maximal independent set in a hypergraph. We present an efficient deterministic NC algorithm for finding a maximal independent set in a hypergraph of dimension 3: the algorithm runs in time O(log 4 n) time on n + m processors of an EREW PRAM and is optimal up to a polylogarithmic factor. Our algorithm adapts the technique of Goldberg and Spencer for finding a maximal independent set in a graph (or hypergraph of dimension 2). It is the first NC algorithm for finding a maximal independent set in a hypergraph of dimension greater than 2.

NC algorithms for real algebraic numbers

Characterizing real algebraic numbers by a sign-sequence (according to Thom's lemma), using a variant of Ben Or Kozan and Reif algorithm for reducing the solving of systems of polynomial inequalities to the problem of counting real zeroes satisfying one polynomial inequality, and using a multivariate Sturm theory generalizing Hermite quadratic forms method for counting real zeroes, we prove that the computations on real algebraic numbers are in NC.

An NC algorithm for recognizing tree adjoining languages

A parallel algorithm is presented for recognizing the class of languages generated by tree adjoining grammars, a tree rewriting system which has applications in natural language processing. This class of languages is known to properly include all context-free languages; for example, the noncontext-free sets {anbncn} and {ww} are in this class. It is shown that the recognition problem for tree adjoining languages can be solved by a concurrent read, concurrent write parallel random-access machine (CRCW PRAM) inO(logn) time using polynomially many processors. Thus, the class of tree adjoining languages is inAC1 and hence inNC. This extends a previous result for context-free languages.

A model classifying algorithms as inherently sequential with applications to graph searching

A model is proposed that can be used to classify algorithms as inherently sequential . The model captures the internal computations of algorithms. Previous work in complexity theory has focused on the solutions algorithms compute. Direct comparison of algorithms within the framework of the model is possible. The model is useful for identifying hard to parallelize constructs that should be avoided by parallel programmers. The model's utility is demonstrated via applications to graph searching. A stack breadth-first search (BFS) algorithm is analyzed and proved inherently sequential. The proof technique used in the reduction is a new one. The result for stack BFS sharply contrasts with a result showing that a queue based BFS algorithm is in NC . An NC algorithm to compute greedy depth-first search numbers in a dag is presented, and a result proving that a combination search strategy called breadth-depth search is inherently sequential is also given.

Conditions for Unique Graph Realizations

The graph realization problem is that of computing the relative locations of a set of vertices placed in Euclidean space, relying only upon some set of inter-vertex distance measurements. This paper is concerned with the closely related problem of determining whether or not a graph has a unique realization. Both these problems are NP-hard, but the proofs rely upon special combinations of edge lengths. If one assumes the vertex locations are unrelated, then the uniqueness question can be approached from a purely graph theoretic angle that ignores edge lengths. This paper identifies three necessary graph theoretic conditions for a graph to have a unique realization in any dimension. Efficient sequential and NC algorithms are presented for each condition, although these algorithms have very different flavors in different dimensions.

A randomized NC algorithm for the maximal tree cover problem

A randomized NC algorithm for the maximal tree cover problem

Simulating (log c n )-wise independence in NC

Abstract : We develop a general framework for removing randomness from randomized NC algorithms whose analysis uses only polyalgorithmic independence. Previously no techniques were known to determine those RNC algorithms depending on more than constant independence. One application of our techniques is an NC algorithm for the set discrepancy problem, which can be used to obtain many other NC algorithms, including a better NC edge coloring algorithm. As another application of our techniques, we provide an NC algorithm for the hypergraph coloring problem.

Parallel recognition of the consecutive ones property with applications

Given a (0, 1)-matrix, the problem of recognizing the consecutive 1's property for rows is to decide whether it is possible to permute the columns such that the resulting matrix has the consecutive 1's in each of its rows. In this paper, we give the first NC algorithm for this problem. The algorithm runs in O(log n + log 2 m) time using O( m 2 n + m 3) processors on Common CRCW PRAM, where m × n is the size of the matrix. The algorithm can be extended to detect the circular 1's property within the same resource bounds. We can also make use of the algorithm to recognize convex bipartite graphs in O(log 2 n) time using O( n 3) processors, where n is the number of vertices in a graph. We further show that the maximum matching problem for arbitrary convex bipartite graphs can be solved within the same complexity bounds, combining the work by Dekel and Sahni, who gave an efficient parallel algorithm for computing maximum matchings in convex bipartite graphs with the condition that the neighbors of each vertex in one vertex set of a bipartite graph occur consecutively in the other vertex set. This broadens the class of graphs for which the maximum matching problem is known to be in NC.

Intersecting Line Segments in Parallel with an Output-Sensitive Number of Processors

An efficient parallel algorithm is given for constructing the arrangement of n line segments in the plane, i.e., the planar graph determined by the segment endpoints and intersections. This algorithm is efficient relative to three efficiency measures—it is an NC algorithm, it has a small time-processor product, and it is output-size sensitive. In particular, it runs in $O(\log n)$ time using $O(n\log n + k)$ processors, where k is the size of the output (which is $\Omega (n^2 )$ in the worst case). The algorithm does not receive the value of k as input, it determines it on-line. A method or solving an important special case of the segment arrangement problem is also shown, namely, when each input segment is parallel to one of the coordinate axes (i.e., iso-oriented). The algorithm for this problem runs in $O(\log n)$ time using an optimal $O(n + k / \log n)$ processors. The model of computation is the CREW PRAM model, where processor allocation must be explicit and global.

NC Algorithms for Recognizing Partial 2-Trees and 3-Trees

The existence of a k-separator in a partial k-tree graph is proved and a linear time algorithm is constructed that finds such a separator in k-trees. This algorithm can be used to obtain a balanced binary decomposition of a k-tree in $O( n\log n )$ time. Some other separation properties of partial k-trees are derived and used to construct a balanced decomposition of an embedding of a k-connected partial k-tree when $k = 2,3$. Finally, NC algorithms are constructed for the recognition of a partial k-tree for $k = 2,3$. For $k = 2$ and $k = 3$ these algorithms run in $O( \log^{2} n )$ time using, respectively, $O( n^3 )$ and $O( {n^4 } )$ processors. Thus, the algorithms for $k = 2,3$ improve considerably the processor bound of Chandrasekharan and Hedetniemi [Proceedings of the 26th Annual Allerton Conference on Communication, Control and Computing, 1989, pp. 283–292] general algorithm for the parallel recognition of partial k-trees that would require $O( \log n )$ time and, respectively, $O( n^{10} )$ and ...

Parallel algorithms for cographs and parity graphs with applications

Parity graphs are a natural extension of bipartite graphs, and as a subclass, they include cographs. In this paper it is shown that the recognition problem for cographs, transitive orientation, maximum node weighted clique, minimum node coloring, minimum weight domination set, minimum fill-in, isomorphism for cographs are in the class NC. It is noted that the cograph recognition is central to the recognition problem for parity graphs, and a NC algorithm for parity graph recognition is presented based on this fact. The recognition algorithms require O(log 2 n) time and use O( mn) processors, where m and n are the number of edges and vertices in the graph respectively. The model of computation used is the CRCW P-RAM (concurrent read concurrent write parallel RAM), where more than one processor can concurrently read from or write into the same memory location. Writing conflicts are resolved in a non-deterministic fashion, i.e., one processor at random succeeds.

Parallel complexity of the regular code problem

The regular code problem (RCP) seeks to decide whether a right linear grammar, G , generates a code, i.e., whether or not (L(G)) ∗ is free over L ( G ). Here L ( G ) is the language generated by G . The regular free monoid problem (RFMP) seeks to decide whether a right linear grammar, G , generates a free monoid. Both problems can be reduced to the linear context free grammar emptiness problem, which in turn can be reduced to matrix inversion. In the case of RCP the reductions give rise to an NC algorithm. In the RFMP case the reduction yields only an EXPTIME algorithm.

Isomorphism testing of k-trees is in NC, for fixed k

Our goal is to develop an NC algorithm for isomorphism testing of k-trees, for fixed k. The k-tree isomorphism problem for arbitrary k, is isomorphism complete and so we would not expect to get an NC algorithm for it.

Coloring algorithms for K5-minor free graphs

In this paper we give an NC algorithm to five color K 5-minor free graphs. We also give a polynomial time algorithm to obtain a four coloring for a K 5-minor free graph.

Parallel Depth-First Search in General Directed Graphs

A directed cycle separator of an n-vertex directed graph is a vertex-simple directed cycle such that when the vertices of the cycle are deleted, the resulting graph has no strongly connected component with more than ${n / 2}$ vertices. It is shown that the problem of finding a directed cycle separator is in randomized NC. It is also proved that computing cycle separators and conducting depth-first search in directed graphs are deterministically NC-equivalent. These two results together yield the first randomized NC algorithm for depth-first search in general directed graphs.

An nc algorithm to recognize hhd-free graphs

The HHD-free graphs are a class of perfect graphs that strictly contain the cographs, the chordal graphs, the Matula-perfect graphs, and the Welsh-Powell opposition graphs. In this paper we present two characterizations of the HHD-free graphs and show how to use them to produce a parallel recognition algorithm which runs in O(log n) time using O(n 4) processors on a concurrent-read, concurrent-write parallel random access machine.

An NC algorithm for Brooks' Theorem

Brooks' Theorem states that any graph G of maximum degree Δ⩾3 can be Δ node colored if and only if G does not contain K Δ+1 as a subgraph. We exhibit an NC algorithm to find a Δ coloring when Brooks' Theorem guarantees it exists.