EREW PRAM Model Research Articles

AN EFFICIENT PARALLEL ALGORITHM FOR THE ASSIGNMENT PROBLEM ON THE PLANE∗

Abstract We consider a parallel algorithm for minimum weight perfect matching on complete bipartite graphs induced by two disjoint sets of points on the plane. The algorithm is designed for the EREW PRAM or EREW RPRAM model of parallel computation with p (a function of n) processors. For points on the Euclidean plane, the algorithm executes in O(n 3/ p 2 + n2log n + n 2.5log n/p) time for p < equation pending We achieve a perfect speedup algorithm when p equation pending

A Parallel Algorithm for Finding Minimum Cutsets in Reducible Graphs

We present a parallel algorithm for finding minimum cutsets in reducible graphs. For a reducible graph that has N nodes our algorithm runs in O(log 3 N) time using O( N 3/log N) PEs on the EREW P-RAM model of computation. We also present a parallel heuristic for finding minimal cutsets in general graphs.

A simple optimal parallel algorithm for the minimum coloring problem on interval graphs

In this paper, we develop a new parallel algorithm for the minimum coloring problem on interval graphs. Our method is both easy to understand and easy to implement. Given a set of n intervals, our parallel algorithm takes O(log n) time and O( n) processors on the EREW PRAM model. Also, if the intervals are sorted, it takes O(log n) time and O( n/log n) processors on the EREW PRAM model. Both the sorted and unsorted cases are cost optimal.

SUB-LOGARITHMIC ALGORITHMS FOR THE LARGEST EMPTY RECTANGLE PROBLEM

We show that the Largest Empty Rectangle problem can be solved by reducing it, in a natural way, to the All Nearest Smaller Values problem. We provide two classes of algorithms: the first one assumes that the input points are available sorted by x (resp. y) coordinate. Our algorithm corresponding to this case runs in O(log log n) time using [Formula: see text] processors in the Common-CRCW-PRAM model. For unsorted input, we present algorithms that run in [Formula: see text] time using [Formula: see text] processors in the Common-CRCW-PRAM, or in O( log n) time using [Formula: see text] processors in the EREW-PRAM model. No sub-logarithmic time parallel algorithms have been previously reported for this problem.

Optimal parallel colouring algorithms for totally decomposable graphs

Call a graph G totally decomposable if there exists a unique rooted tree T(G) whose leaves correspond to the vertices of G and whose internal nodes correspond to certain graph operations. As it turns out, totally decomposable graphs are extremely attractive from the computational point of view since many notoriously difficult problems on arbitrary graph become tractable for this class. We present optimal cost parallel colouring algorithms for a vast class of totally decomposable graphs. With an n-vertex graph represented by its parse tree input, all our algorithms run in O(n/p + log n) time using p (p ≤ n log n) processors in the EREW-PRAM model.

Efficient parallel processing of image contours

Describes two parallel algorithms for ranking the pixels on a curve in O (log N) time using either an EREW or CREW PRAM model. The algorithms accomplish this with N processors for a square root N* square root N image. After applying such an algorithm to an image, it is possible to move the pixels from a curve into processors having consecutive addresses. This is important because one can subsequently apply many algorithms to the curve (such as piecewise linear approximation algorithms or point in polygon tests) using segmented scan operations (i.e. parallel prefix operations). Scan operations can be executed in logarithmic time on many interconnection networks, such as hypercube, tree, butterfly, and shuffle exchange machines as well as on the EREW PRAM. The algorithms were implemented on the hypercube structured Connection Machine, and various performance tests were conducted. >

An optimal parallel algorithm for the domatic partition problem on an interval graph given its sorted model

We develop a parallel algorithm for the domatic partition problem on interval graphs under the EREW PRAM model. Given a set of n intervals with their 2 n endpoints sorted, our algorithm takes O(log n)time and O( n/log n )processors. The cost (time-processor product) of our algorithm is O( n). Therefore our parallel algorithm is optimal. If these n intervals are not sorted, we can solve this problem in O(log n) time by using O( n) processors. This is optimal too. Our algorithm is based on some observations about the degrees of the intervals. These observations result in a very elegant parallel algorithm.

An efficient parallel algorithm for the row minima of a totally monotone matrix

We give a parallel algorithm for the problem of computing the row minima of a totally monotone two-dimensional matrix. Whereas the previous best CREW-PRAM algorithm for this problem ran in O(log n log log n) time with O( n log log n ) processors, our algorithms runs in O(log n) time with O( n) processors in the (weaker) EREW-PRAM model. Thus we simultaneously improve the time complexity without any deterioration in the time × processors product, even using a weaker model of parallel computation.

A parallel algorithm to construct a dominance graph on nonoverlapping rectangles

A parallel algorithm to generate the dominance graph on a collection of nonoverlapping iso-oriented rectangles is presented. This graph arises from the constraint graph commonly used in compaction algorithms for VLSI circuits. The dominance graph expresses the notion of “aboveness” on a collection of nonoverlapping rectangles: it is the directed graph which contains an edge from a rectangleb to rectanglec iffc is immediately aboveb. The algorithm is based on the divide and conquer paradigm; in the EREW PRAM model, it has time complexityO(log2n), usingn/logn processors. Its processor-time product isO(nlogn), which is optimal.

Optimal parallel algorithms for finding cut vertices and bridges of interval graphs

We present O(log n) time algorithm in the EREW PRAM model, using n/log n processors, to find cut vertices, bridges, and blocks (often called biconnected components) of an interval graph having n vertices. It is assumed the interval graph is represented by an interval model, with ends presorted. If the ends are not presorted, our algorithms, preceded by an optimal sort, form an O(log n) time algorithm using n processors, which is shown to be optimal. The algorithms rely heavily on the parallel prefix algorithm.

Optimal parallel algorithms for point-set and polygon problems

In this paper we give parallel algorithms for a number of problems defined on point sets and polygons. All our algorithms have optimalT(n) * P(n) products, whereT(n) is the time complexity andP(n) is the number of processors used, and are for the EREW PRAM or CREW PRAM models. Our algorithms provide parallel analogues to well-known phenomena from sequential computational geometry, such as the fact that problems for polygons can oftentimes be solved more efficiently than point-set problems, and that nearest-neighbor problems can be solved without explicitly constructing a Voronoi diagram.

A note on the reconstruction of a binary tree from its traversals

We present a linear-time sequential algorithm for the construction of a binary tree, given its preorder and inorder traversals. The algorithm leads to an optimal O(log n) time parallel algorithm on the EREW PRAM model, where n is the number of nodes in the tree.

A fast cost-optimal parallel algorithm for the lowest common ancestor problem

The problem of computing the lowest common ancestors of all pairs of nodes in a rooted tree is central in a large number of practical applications. The purpose of this note is to propose a very simple cost-optimal parallel algorithm to solve the lowest common ancestor problem. More precisely, with an n-node rooted tree as input, our algorithm runs in O(log n) time using O( n 2 lopg n) processors on the EREW-PRAM model.

An optimal algorithm for reconstructing a binary tree

We solve the difficult part of constructing a binary tree from its inorder and preorder traversals, finding the (right-son, parent) pairs, and outline an optimal parallel algorithm in the EREW PRAM model for constructing the binary tree.

Optimal parallel algorithms for problems modeled by a family of intervals

A family of intervals on the real line provides a natural model for a vast number of scheduling and VLSI problems. Recently, a number of parallel algorithms to solve a variety of practical problems on such a family of intervals have been proposed in the literature. The authors develop computational tools and show how they can be used for the purpose of devising cost-optimal parallel algorithms for a number of interval-related problems, including finding a largest subset of pairwise nonoverlapping intervals, a minimum dominating subset of intervals, along with algorithms to compute the shortest path between a pair of intervals and, based on the shortest path, a parallel algorithm to find the center of the family of intervals. More precisely, with an arbitrary family of n intervals as input, all the algorithms run in O(log n) time using O(n) processors in the EREW-PRAM model of computation. >

OPTIMAL PARALLEL ENCODING AND DECODING ALGORITHMS FOR TREES

Encoding the shape of a binary tree is a basic step in a number of algorithms in integrated circuit design, automated theorem proving, and game playing. We propose cost-optimal parallel algorithms to solve the binary tree encoding/decoding problem. Specifically, we encode the relevant shape information of an n-node binary tree in a 2n bitstring. Conversely, given an arbitrary 2n bitstring we reconstruct the shape of the corresponding binary tree, if such a tree exists. All our algorithms run in O (log n) time using O (n/log n) processors in the EREW-PRAM model of computation.

Breadth-first traversal of trees and integer sorting in parallel

We present a cost-optimal parallel algorithm for traversing a general tree in breadth-first fashion. For a tree with n nodes, this algorithm requires O( n/ p+log n) time employing p processors on the EREW PRAM model. To the best of our knowledge, it is the first parallel algorithm for breadth-first tree-traversal, which has O(log n) time complexity and yet being cost-optimal for p=O( n/log n) on the EREW PRAM. Our approach is based on a novel idea which converts the breadth-first traversal problem into a parentheses matching problem. As an application of this technique, we design a simple but elegant parallel algorithm for sorting a special class of integers in which elements in any two consecutive places of the input sequence differ at most by unity. The proposed sorting algorithm is stable and it achieves the same performance as that of our breadth-first traversal algorithm.

On parallel integer sorting

We present an optimal algorithm for sortingn integers in the range [1,nc] (for any constantc) for the EREW PRAM model where the word length isne, for any e>0. Using this algorithm, the best known upper bound for integer sorting on the (O(logn) word length) EREW PRAM model is improved. In addition, a novel parallel range reduction algorithm which results in a near optimal randomized integer sorting algorthm is presented. For the case when the keys are uniformly distributed integers in an arbitrary range, we give an algorithm whose expected running time is optimal.

An optimal parallel algorithm to construct a deap

Recently, Carlsson [3] proposed a variation of the heap data structure as an efficient implementation of a double-ended priority queue. This new data structure is referred to as the deap. We show that constructing a deap with special properties can be done very easily, both sequentially and in parallel, by reducing the problem to selection and heap construction. Our parallel algorithm can be implemented to run in O(log n log ∗ n) time using an optimal number of processors in the EREW-PRAM model or in O(log n) time using an optimal number of processors in the CRCW model.

An efficient parallel algorithm for multiselection

The problem of multiselection arises frequently in databases. Here, given an unordered set S of n records and a sequence of m integers 1 ⩽ q 1 < q 2 < … < q m ⩽ n we are interested in answering queries of the type ‘find the q i th smallest elements in S’, the problem is to answer all these queries as fast as possible. We propose an efficient parallel algorithm for multiselection, running in O( n/p log 2 m) time using p processors with 1 ⩽ p ⩽ [ n/log n log* n], in the EREW-PRAM model.