EREW Research Articles

Partially effective randomization in simulations between ARBITRARY and COMMON PRAMs

It is known that Θ( log n log log n ) steps are needed to simulate one step of ARBITRARY CRCW PRAMs by COMMON CRCW PRAMs, but it was open whether there is a faster simulation when randomization is allowed. This paper gives both positive and negative answers. (i) It is shown that one step of ARBITRARY can be simulated by O( log m k( log log m− log k) + log log n) steps on randomized COMMON with error-rate n − c , where m= n/ k is the number of different memory cells into which at least one processor of the simulated PRAM attempts to write. The deterministic Θ( log n log log n ) -step simulation does not become faster for smaller m, while our randomized simulation becomes O( log log n) when m⩽ n log log n log n . (ii) It is shown that when m=n, Ω( log n log log n ) steps are needed to simulate one step of ARBITRARY by COMMON even if randomization is allowed. This lower-bound result needs some assumption on processor communication but it strongly suggests randomization does not help when m is small.

An Optimal Parallel Co-Connectivity Algorithm

In this paper we consider the problem of computing the connected components of the complement of a given graph. We describe a simple sequential algorithm for this problem, which works on the input graph and not on its complement, and which for a graph on n vertices and m edges runs in optimal O(n+m) time. Moreover, unlike previous linear co-connectivity algorithms, this algorithm admits efficient parallelization, leading to an optimal O(log n)-time and O((n+m)log n)-processor algorithm on the EREW PRAM model of computation. It is worth noting that, for the related problem of computing the connected components of a graph, no optimal deterministic parallel algorithm is currently available. The co-connectivity algorithms find applications in a number of problems. In fact, we also include a parallel recognition algorithm for weakly triangulated graphs, which takes advantage of the parallel co-connectivity algorithm and achieves an O(log2 n) time complexity using O((n+m2) log n) processors on the EREW PRAM model of computation.

Parallel algorithms for P4-comparability graphs

We consider two problems pertaining to P 4-comparability graphs, namely, the problem of recognizing whether a simple undirected graph is a P 4-comparability graph and the problem of producing an acyclic P 4-transitive orientation of such a graph. Sequential algorithms for these problems have been presented by Hoàng and Reed and very recently by Raschle and Simon, and by Nikolopoulos and Palios. In this paper, we establish properties of P 4-comparability graphs which allow us to describe parallel algorithms for the recognition and orientation problems on this class of graphs; for a graph on n vertices and m edges, our algorithms run in O(log 2 n) time and require O( nm/log n) processors on the CREW PRAM model. Since the currently fastest sequential algorithms for these problems run in O( nm) time, our algorithms are cost-efficient; moreover, to the best of our knowledge, this is the first attempt to introduce parallelization in problems involving P 4-comparability graphs. Our approach relies on the parallel computation and proper orientation of the P 4-components of the input graph.

COLORING ALGORITHMS ON SUBCUBIC GRAPHS

We present efficient algorithms for three coloring problems on subcubic graphs. (A subcubic graph has maximum degree at most three.) The first algorithm is for 4-edge coloring, or more generally, 4-list-edge coloring. Our algorithm runs in linear time, and appears to be simpler than previous ones. The second algorithm is the first randomized EREW PRAM algorithm for the same problem. It uses O(n/ log n) processors and runs in O( log n) time with high probability, where n is the number of vertices of the graph. The third algorithm is the first linear-time algorithm to 5-total-color subcubic graphs. The fourth algorithm generalizes this to get the first linear-time algorithm to 5-list-total-color subcubic graphs. Our sequential algorithms are based on a method of ordering the vertices and edges by traversing a spanning tree of a graph in a bottom-up fashion. Our parallel algorithm is based on a simple decomposition principle for subcubic graphs.

Optimal Sequential and Parallel Algorithms for Cut Vertices and Bridges on Trapezoid Graphs

Let G be a graph. A component of G is a maximal connected subgraph in G. A vertex v is a cut vertex of G if k(G-v) > k(G), where k(G) is the number of components in G. Similarly, an edge e is a bridge of G if k(G-e) > k(G). In this paper, we will propose new O(n) algorithms for finding cut vertices and bridges of a trapezoid graph, assuming the trapezoid diagram is given. Our algorithms can be easily parallelized on the EREW PRAM computational model so that cut vertices and bridges can be found in O(log n) time by using O(n / log n) processors.

Optimal Sequential and Parallel Algorithms to Compute All Cut Vertices on Trapezoid Graphs

In this paper, a sequential algorithm is presented to find all cut-vertices on trapezoid graphs. To every trapezoid graph G there is a corresponding trapezoid representation. If all the 4n corner points of n trapezoids, in a trapezoid representation of a trapezoid graph G with n vertices, are given, then the proposed sequential algorithm runs in O(n) time. Parallel implementation of this algorithm can be done in O(log n) time using O(n/ log n) processors on an EREW PRAM model.

PARALLEL ALGORITHMS FOR VEHICLE ROUTING PROBLEMS

Vehicle routing problems involve the navigation of one or more vehicles through a network of locations. Locations have associated handling times as well as time windows during which they are active. The arcs connecting locations have time costs associated with them. In this paper, we consider two different problems in single vehicle routing. The first is to find least time cost routes between all pairs of nodes in a network for navigating vehicles; we call this the all pairs routing problem. We show that there is an O( log 3 n) time parallel algorithm using a polynomial number of processors for this problem on a CREW PRAM. We next consider the problem in which a vehicle services all locations in a network. Here, locations can be passed through at any time but only serviced during their time window. The general problem is [Formula: see text] -complete under even fairly stringent restrictions but polynomial algorithms have been developed for some special cases. In particular, when the network is a line, there is no time cost in servicing a location, and all time windows are unbounded at either their lower or upper end, O(n2) algorithms have been developed. We show that under the same conditions, we can reduce this problem to the all pairs routing problem and therefore obtain an O( log 3 n) time parallel algorithm on a CREW PRAM.

A simple and fast parallel coloring algorithm for distance-hereditary graphs

In the literature, there are quite a few sequential and parallel algorithms to solve problems on distance-hereditary graphs. Two well-known classes of graphs, which contain trees and cographs, belong to distance-hereditary graphs. We consider the vertex-coloring problem on distance-hereditary graphs. Let T/sub d/(|V|, |E|) and P/sub d/d(|V|, |E|) denote the time and processor complexities, respectively, required to construct a decomposition tree representation of a distance-hereditary graph G=(V,E) on a PRAM model M/sub d/. Our algorithm runs in O(T/sub d/(|V|, |E|)+log|V|) time using O(P/sub d/(|V|, |E|)+|V|/log|V|) processors on M/sub d/. The best known result for constructing a decomposition tree needs O(log/sup 2/ |V|) time using O(|V|+|E|) processors on a CREW PRAM. If a decomposition tree is provided as input, we solve the problem in O(log |V|) time using O(|V|/log |V|) processors on an EREW PRAM. To the best of our knowledge, there is no parallel algorithm for this problem on distance-hereditary graphs.

Scheduling interval orders with communication delays in parallel

We investigate the complexity of computing an optimal m-processor schedule for a system of n unit execution time tasks constrained by an interval order, subject to unit delays for interprocessor communication. Our results are twofold. First, we show that the problem can be solved by a sequential algorithm in linear time. Second, we present a fast parallel algorithm that solves the problem on the EREW PRAM in time O( log 2 n) using n 3/ log n processors and on the CRCW PRAM in time O( log n) using n 3 processors. This is the first NC algorithm for this problem.

The complexity of planarity testing

We clarify the computational complexity of planarity testing, by showing that planarity testing is hard for L, and lies in SL. This nearly settles the question, since it is widely conjectured that L=SL. The upper bound of SL matches the lower bound of L in the context of (nonuniform) circuit complexity, since L/poly is equal to SL/poly. Similarly, we show that a planar embedding, when one exists, can be found in FLSL. Previously, these problems were known to reside in the complexity class AC1, via the O(logn) time CRCW PRAM algorithm of Ramachandran and Reif, although planarity checking for degree-three graphs had been shown to be in SL [Chicago J. Theoret. Comput. Sci. (1995); J. ACM 31 (2) (1984) 401].

Parallel algorithms for Hamiltonian problems on quasi-threshold graphs

In this paper we show structural and algorithmic properties on the class of quasi-threshold graphs, or QT-graphs for short, and prove necessary and sufficient conditions for a QT-graph to be Hamiltonian. Based on these properties and conditions, we construct an efficient parallel algorithm for finding a Hamiltonian cycle in a QT-graph; for an input graph on n vertices and m edges, our algorithm takes O( log n) time and requires O( n+ m) processors on the CREW PRAM model. In addition, we show that the problem of recognizing whether a QT-graph is a Hamiltonian graph and the problem of computing the Hamiltonian completion number of a nonHamiltonian QT-graph can also be solved in O( log n) time with O( n+ m) processors. Our algorithms rely on O( log n) -time parallel algorithms, which we develop here, for constructing tree representations of a QT-graph; we show that a QT-graph G has a unique tree representation, that is, a tree structure which meets the structural properties of G. We also present parallel algorithms for other optimization problems on QT-graphs which run in O( log n) time using a linear number of processors.

Gossiping and broadcasting versus computing functions in networks

In the theory of dissemination of information in interconnection networks (gossiping and broadcasting) one assumes that a message consists of a set of distinguishable, atomic pieces of information, and that one communication pattern is used for solving a task. In this paper, a close connection is established between this theory and a situation in which functions are computed in synchronous networks without restrictions on the type of message used and with possibly different communication patterns for different inputs. The following restriction on the way processors communicate turns out to be essential: (∗) “ Predictable reception”: At the beginning of a step a processor knows whether it is to receive a message across one of its links or not. We show that if (∗) holds then computing an n-ary function with a “critical input” (e.g., the OR of n bits) and distributing the result to all processors on an n-processor network G takes exactly as long as performing gossiping in G. Further we study the complexity of broadcasting one bit in a synchronous network, assuming that in one step a processor can send only one message, but without assuming (∗), and broadcasting one bit on parallel random-access machines (PRAMs) and distributed memory machines (DMMs) with the A RBITRARY access resolution rule.

Fast parallel edge colouring of graphs

The following EREW PRAM algorithms for edge-colouring a general graph are presented: 1. an algorithm that finds a ( Δ+ d)-edge-colouring, 1⩽ d< Δ, in O(( log d+(Δ/d) 4) log 2 n) time, using n+ m processors; 2. an algorithm that finds a Δ 1+ ε -edge-colouring, 0< ε<1, in O( log Δ log ∗ n) time, using nΔ 1+ ε processors.

Optimal Sequential And Parallel Algorithms To Compute A Steiner Tree On Permutation Graphs

This paper presents an optimal sequential and an optimal parallel algorithm to compute a minimum cardinality Steiner set and a Steiner tree. The sequential algorithm takes O ( n ) time and parallel algorithm takes O (log n ) time and O ( n /log n ) processors on an EREW PRAM model.

Fast parallel algorithm for distance transform

We present an O((log log N)/sup 2/) -time algorithm for computing the distance transform of an N /spl times/ N binary image. Our algorithm is designed for the common concurrent read concurrent write parallel random access machine (CRCW PRAM) and requires O(N/sup 2+/spl epsi///log log N) processors, for any /spl epsi/ such that 0 < /spl epsi/ < 1. Our algorithm is based on a novel deterministic sampling scheme and can be used for computing distance transforms for a very general class of distance functions. We also present a scalable version of our algorithm when the number of processors is available p/sup 2+/spl epsi///log log p for some p < N. In this case, our algorithm runs in O((N/sup 2//p/sup 2/)+(N/p) log log p + (log log p)/sup 2/) time. This scalable algorithm is more practical since usually the number of available processors is much less than the size of the image.

An efficient parallel algorithm for scheduling interval ordered tasks

We present an efficient parallel algorithm for scheduling n unit length tasks on m identical processors when the precedence graphs are interval orders. Our algorithm requires O( log 2 v+(n log n)/v) time and O( nv 2+ n 2) operations on the CREW PRAM, where v can be any number between 1 and n. By choosing v= n , we obtain an O( n log n) -time algorithm with O( n 2) operations. For v=n/ log n , we have an O( log 2 n) -time algorithm with O(n 3/ log 2 n) operations. The previous solution takes O( log 2 n) time with O(n 3 log 2 n) operations on the CREW PRAM. Our improvement is mainly due to a simple dynamic programming recurrence for computing the lengths of optimal schedules and a reduction of the m-processor scheduling problem for interval orders to that of finding a maximum matching in a convex bipartite graph.

Faster output-sensitive parallel algorithms for 3D convex hulls and vector maxima

In this paper we focus on the problem of designing very fast parallel algorithms for the convex hull and the vector maxima problems in three dimensions that are output-size sensitive. Our algorithms achieve O( log log 2 n log h) parallel time and optimal O(n log h) work with high probability in the CRCW PRAM where n and h are the input and output size, respectively. These bounds are independent of the input distribution and are faster than the previously known algorithms. We also present an optimal speed-up (with respect to the input size only) sublogarithmic time algorithm that uses superlinear number of processors for vector maxima in three dimensions.

A Randomized Linear-Work EREW PRAM Algorithm to Find a Minimum Spanning Forest

We present a randomized EREW PRAM algorithm to find a minimum spanning forest in a weighted undirected graph. On an n -vertex graph the algorithm runs in o(( log n)1+ɛ) expected time for any ɛ >0 and performs linear expected work. This is the first linear-work, polylog-time algorithm on the EREW PRAM for this problem. This also gives parallel algorithms that perform expected linear work on two general-purpose models of parallel computation—the QSM and the BSP.

Parallel computation of the euclidean distance transform on a three-dimensional image array

In a two- or three-dimensional image array, the computation of Euclidean distance transform (EDT) is an important task. With the increasing application of 3D voxel images, it is useful to consider the distance transform of a 3D digital image array. Because the EDT computation is a global operation, it is prohibitively time consuming when performing the EDT for image processing. In order to provide the efficient transform computations, parallelism is employed. We first derive several important geometry relations and properties among parallel planes. We then, develop a parallel algorithm for the three-dimensional Euclidean distance transform (3D-EDT) on the EREW PRAM computation model. The time complexity of our parallel algorithm is O(log/sup 2/ N) for an N/spl times/N/spl times/N image array and this is currently the best known result. A generalized parallel algorithm for the 3D-EDT is also proposed. We implement the proposed algorithms sequentially, the performance of which exceeds the existing algorithms (proposed by Yamada, 1984). Finally, we develop the corresponding parallel programs on both the emulated EREW PRAM model computer and the IBM SP2 to verify the speed-up properties of the proposed algorithms.

Efficient Parallel Algorithms for Planar st-Graphs

Planar st -graphs find applications in a number of areas. In this paper we present efficient parallel algorithms for solving several fundamental problems on planar st -graphs. The problems we consider include all-pairs shortest paths in weighted planar st -graphs, single-source shortest paths in weighted planar layered digraphs (which can be reduced to single-source shortest paths in certain special planar st -graphs), and depth-first search in planar st -graphs. Our parallel shortest path techniques exploit the specific geometric and graphic structures of planar st -graphs, and involve schemes for partitioning planar st -graphs into subgraphs in a way that ensures that the resulting path length matrices have a monotonicity property [1], [2]. The parallel algorithms we obtain are a considerable improvement over the previously best known solutions (when they are applied to these st -graph problems), and are in fact relatively simple. The parallel computational models we use are the CREW PRAM and EREW PRAM.