Arbitrary CRCW PRAM Research Articles

Output-sensitive algorithms for optimally constructing the upper envelope of straight line segments in parallel

The importance of the sensitivity of an algorithm to the output size of a problem is well-known especially if the upper bound on the output size is known to be not too large. In this paper we focus on the problem of designing very fast parallel algorithms for constructing the upper envelope of straight-line segments that achieve the O ( n log H ) work-bound for input size n and output size H. When the output size is small, our algorithms run faster than the algorithms whose running times are sensitive only to the input size. Since the upper bound on the output size of the upper envelop problem is known to be small ( n α ( n ) ), where α ( n ) is a slowly growing inverse-Ackerman's function, the algorithms are no worse in cost than the previous algorithms in the worst case of the output size. Our algorithms are designed for the arbitrary CRCW PRAM model. We first describe an O ( log n · ( log H + log log n ) ) time deterministic algorithm for the problem, that achieves O ( n log H ) work bound for H = Ω ( log n ) . We then present a fast randomized algorithm that runs in expected time O ( log H · log log n ) with high probability and does O ( n log H ) work. For log H = Ω ( log log n ) , we can achieve the running time of O ( log H ) while simultaneously keeping the work optimal. We also present a fast randomized algorithm that runs in O ˜ ( log n / log k ) time with nk processors, k > log Ω ( 1 ) n . The algorithms do not assume any prior input distribution and the running times hold with high probability.

Efficient Graph-Theoretic Algorithms on a Linear Array with a Reconfigurable Pipelined Bus System

We present efficient algorithms for solving several fundamental graph-theoretic problems on a Linear Array with a Reconfigurable Pipelined Bus System (LARPBS), one of the recently proposed models of computation based on optical buses. Our algorithms include finding connected components, minimum spanning forest, biconnected components, bridges and articulation points for an undirected graph. We compute the connected components and minimum spanning forest of a graph in O(log n) time using O(m+n) processors where m and n are the number of edges and vertices in the graph and m=O(n2) for a dense graph. Both the processor and time complexities of these two algorithms match the complexities of algorithms on the Arbitrary and Priority CRCW PRAM models which are two of the strongest PRAM models. The algorithms for these two problems published by Li et al. l7r have been considered to be the most efficient on the LARPBS model till now. Their algorithm l7r for these two problems require O(log n) time and O(n3/log n) processors. Hence, our algorithms have the same time complexity but require less processors. Our algorithms for computing biconnected components, bridges and articulation points of a graph run in O(log n) time on an LARPBS with O(n2) processors. No previous algorithm was known for these latter problems on the LARPBS.

An Efficient [formula omitted][formula omitted] Algorithm for a Sparse k-Edge-Connectivity Certificate

We present an efficient NC algorithm for finding a sparse k-edge-connectivity certificate of a multigraph G. Our algorithm runs in O((logkn)(logk)2(logn)2) time using O(k(n+m′)) processors on an ARBITRARY CRCW PRAM, where n and m′ stand for the numbers of vertices in G and edges in the simplified graph of G, respectively.

A Faster Implementation of a Parallel Tree Contraction Scheme and Its Application on Distance-Hereditary Graphs

We consider a parallel tree contraction scheme which in each contraction phase removes leaves and nodes in the maximal chains. Let T(n) and P(n) denote the time and processor complexity required to compute the all nearest smaller values (ANSV) and the minimum of n values for input elements drawn from the integer domain [1…n]. In this paper, we give a faster implementation of the tree contraction scheme which takes O(logn·T(n)) time using P(n) processors on an arbitrary CRCW PRAM. The current best results of T(n) and P(n) are O(logloglogn) and O(n/logloglogn), respectively. To our knowledge, the previously best known implementation needs O(log2n) time using O(n/logn) processors on an EREW PRAM. The faster parallel implementation of the tree contraction scheme may be of interests by itself. We then show the above scheme can be utilized to solve problems on distance-hereditary graphs. We provide a data structure to represent a connected distance-hereditary graph in the form of a rooted tree. By applying the above tree contraction scheme on our data structure together with graph theoretical properties, we solve the problems of finding a minimum connected γ-dominating set and finding a minimum γ-dominating clique on a distance-hereditary graph in O(logn·T(n)) time using O(P(n)+(n+m)/T(n)) processors on an arbitrary CRCW PRAM, where n and m are the number of vertices and edges of the given graph, respectively. The above result implies several other problems related to the minimum γ-dominating clique problem can be solved with the same parallel complexities.

An optimal parallel algorithm for sorting multisets

We consider the problem of sorting n numbers that contain only k distinct values. We present a randomized arbitrary CRCW PRAM algorithm that runs in O( log n) time using (n log k) log n processors. The same algorithm runs in O((log n) log log n) time with a total work of O( n ( log k) 1 + ε ) for any fixed ε < 0. All the stated bounds hold with high probability.

Ultrafast Expected Time Parallel Algorithms

It was shown previously that sortingnitems intonlocations with a polynomial number of processors requires Ω(logn/loglogn) time. We sidestep this lower bound with the idea of padded sorting, or sortingnitems inton+o(n) locations. Because many problems do not rely on the exact rank of sorted items, a padded sort is often just as useful as an unpadded sort. Our algorithm for padded sort runs on the tolerant concurrent read, concurrent write parallel random access machine (CRCW PRAM) and takes Θ(loglogn/logloglogn) expected time usingnlogloglogn/loglognprocessors, assuming the items are taken from a uniform distribution. Using similar techniques we solve some computational geometry problems, including Voronoi diagram, with the same processor and time bounds, assuming points are taken from a uniform distribution in the unit square. Further, we present an arbitrary CRCW PRAM algorithm to solve the closest pair problem in constant expected time withnprocessors regardless of the distribution of points. All of these algorithms achieve linear speedup in expected time over their optimal serial counterparts.

Optimal, output-sensitive algorithms for constructing planar hulls in parallel

In this paper we focus on the problem of designing very fast parallel algorithms for the planar convex hull problem that achieve the optimal O( nlog H) work-bound for input size n and output size H. Our algorithms are designed for the arbitrary CRCW PRAM model. We first describe a very simple O(log nlog H) time optimal deterministic algorithm for the planar hulls which is an improvement over the previously known Ω( log 2n) time algorithm for small outputs. For larger values of H, we can achieve a running time of O(log nloglog n) steps with optimal work. We also present a fast randomized algorithm that runs in expected time O(log H·loglog n) and does optimal O( nlog H) work. For logH = Ω( loglogn) , we can achieve the optimal running time of O(log H) while simultaneously keeping the work optimal. When log H is o(log n), our results improve upon the previously best known Θ(log n) expected time randomized algorithm of Ghouse and Goodrich. The randomized algorithms do not assume any input distribution and the running times hold with high probability.

A faster parallel algorithm for k-connectivity

A new parallel algorithm for graph k-connectivity is shown. It runs in O( k log log k log n) time using ( n + k 2) k( C( n, m) + kn) processors on the ARBITRARY CRCW PRAM model, where C( n, m) is the number of processors required to compute the connected components in logarithmic time. The previous best algorithm runs in ( Ok 2 log n) time using ( n + k 2) kC( n, m) processors (Khuller et al., 1991). When k = log n for example, our new algorithm runs in time O( log 2 n log log log n) against O( log 3 n ) of Khuller's algorithm, i.e., almost an improvement of a factor of log n. The number of processors does not change (under the big-O notation) if m ⩾ kn log n, since C( n, m) is at least (m + n) log n . If we use ( n + k 2) k( C( n, m) + k 1 + ε n) processors, the bound can be further decreased to O( k log n).

OPTIMAL BUCKET SORTING AND OVERLAP REPRESENTATIONS

In this paper, we investigate the problems of sorting integers by bucket sort and of computing minimal interval and circular are overlap representations, and give several optimal algorithms. We show that, given n linearly ranged integers, sorting can be done • in O(log n) time with O(n/log n ) EREW PRAM processors, or in O(logn/log logn) time with O(logn log n / log n) Common CRCW PRAM processors, if the integers are distinct; • in O(log n /log log n) time with O(n log log n / log n ) Arbitrary CRCW PRAM processors, if a constant upper bounded number of integers have a constant lower bounded multiplicity. We also show that, among other things, given an s× t interval or circular are overlap representation matrix, • a minimal interval overlap representation can be obtained in O(log(st)) time with O(st /log(st)) EREW PRAM processors, or in O(log t / log log t) time with O( st log log t / logt ) Common CRCW PRAM processors, or in O(1) time with O(st) BSR processors; • a minimal circular are overlap representation can be obtained in O(st) time.

Parallel maximum independent set in convex bipartite graphs

Abstract A bipartite graph G = (V, W, E) is called convex if the vertices in W can be ordered in such a way that the elements of W adjacent to any vertex υ ϵ V form an interval (i.e. a sequence consecutively numbered vertices). Such a graph can be represented in a compact form that requires O(n) space, where n = max{¦V¦, ¦W¦} . Given a convex bipartite graph G in the compact form Dekel and Sahni designed an O(log2(n))-time, n-processor EREW PRAM algorithm to compute a maximum matching in G. We show that the matching produced by their algorithm can be used to construct optimally in parallel a maximum set of independent vertices. Our algorithm runs in O(logn) time with n logn processors on an Arbitrary CRCW PRAM.

AN OPTIMAL RANDOMIZED PARALLEL ALGORITHM FOR THE SINGLE FUNCTION COARSEST PARTITION PROBLEM

We describe a randomized parallel algorithm to solve the single function coarsest partition problem. The algorithm runs in O( log n) time using O(n) operations with high probability on the Priority CRCW PRAM. The previous best known algorithms run in O( log 2 n) time using O(n log 2 n) operations on the CREW PRAM and O( log n) time using O(n log log n) operations on the Arbitrary CRCW PRAM. The technique presented can be used to generate the Euler tour of a rooted tree optimally from the parent representation.

A new unifying heuristic algorithm for the undirected minimum cut problems using minimum range cut algorithms

Given a connected undirected multigraph with n vertices and m edges, we first propose a new unifying heuristic approach to approximately solving the minimum cut and the s- t minimum cut problems by using efficient algorithms for the corresponding minimum range cut problems. Our method is based on the association of the range value of a cut and its cut value when each edge weight is chosen uniformly randomly from the fixed interval. Our computational experiments demonstrate that this approach produces very good approximate solutions. We shall also propose an O(log 2 n) time parallel algorithm using O( n 2) processors on an arbitrary CRCW PRAM model for the minimum range cut problems, by which we can efficiently obtain approximate minimum cuts in poly-log time using a polynomial number of processors.

Sorting strings and constructing digital search trees in parallel

We describe two simple optimal-work parallel algorithms for sorting a list L= ( X 1, X 2, …, X m ) of m strings over an arbitrary alphabet Σ, where ∑ i = 1 m¦X i¦ = n and two elements of Σ can be compared in unit time using a single processor. The first algorithm is a deterministic algorithm that runs in O( log 2 m/ log log m) time and the second is a randomized algorithm that runs in O( logm) time. Both algorithms use O( m log m + n) operations. Compared to the best-known parallel algorithms for sorting strings, our algorithms offer the following improvements. 1. 1. The total number of operations used by our algorithms is optimal while all previous parallel algorithms use a nonoptimal number of operations. 2. 2. We make no assumption about the alphabet while the previous algorithms assume that the alphabet is restricted to {1, 2, …, n o(1) }. 3. 3. The computation model assumed by our algorithms is the Common CRCW PRAM unlike the known algorithms that assume the Arbitrary CRCW PRAM. 4. 4. Our algorithms use O( m log m + n) space, while the previous parallel algorithms use O( n 1 + ε ) space, where ε is a positive constant. We also present optimal-work parallel algorithms to construct a digital search tree for a given set of strings and to search for a string in a sorted list of strings. We use our parallel sorting algorithms to solve the problem of determining a minimal starting point of a circular string with respect to lexicographic ordering. Our solution improves upon the previous best-known result to solve this problem.

Efficient Parallel Algorithms for Graphs of Bounded Tree-Width

We present an efficient parallel algorithm for the tree-decomposition problem for fixed widthw. The algorithm runs in time O(log3n) and uses O(n) processors on an ARBITRARY CRCW PRAM. The sequential complexity of our tree-decomposition algorithm is O(nlog2n). The tree-decomposition algorithm enables us to construct efficient parallel algorithms for a broad class of problems, when restricted to graphs of tree-width at mostw. Many of these problems areNP-complete for general graphs.

O(log logn)-time integer geometry on the CRCW PRAM

We study problems in computational geometry on PRAMs under the assumption that input objects are specified by points withO(logn)-bit coordinates, or, equivalently, with polynomially bounded integer coordinates. We show that in this setting many geometric problems can be solved in time O(log logn). The following five specific problems are investigated:closest pair of points, intersection of convex polygons, intersection of manhattan line segments, dominating set, andlargest empty square. Algorithms solving them are developed which operate in time O(log logn) on the arbitrary CRCW PRAM. The number of processors used is eitherO(n) orO(n logn).

An efficient parallel algorithm for the single function coarsest partition problem

We describe an efficient parallel algorithm to solve the single function coarsest partition problem. The algorithm runs in O (log n) time using O( n log log n) operations on the arbitrary CRCW PRAM. The previous best-known algorithms run in O(log 2 n) time using O( n log 2 n) operations on the CREW PRAM, and O(log n) time using O ( n log n) operations on the arbitrary CRCW PRAM. Our solution is based on efficient algorithms for solving several subproblems that are of independent interest. In particular, we present efficient parallel algorithms to find a minimal starting point of a circular string with respect to lexicographic ordering and to sort lexicographically a list of strings of different lengths.

Optimal parallel algorithms for coloring bounded degree graphs and finding maximal independent sets in rooted trees

For any fixed 1 k>0, we obtain (a) an O( α 2 log α log ( k) n) time parallel algorithm for ( α + 1) coloring an α-degree graph with n/log ( k) n processors on an EREW PRAM, (b) an O( α 2 log α log ( k) n) time parallel algorithm for 3-coloring an α-degree rooted tree with n/log ( k) n processors on a CREW PRAM, (c) an O(log ( k) n) time parallel algorithm for finding a Maximal Independent Set of a rooted tree on an ARBITRARY CRCW PRAM.

Parallel algorithms for all maximal equally-spaced collinear sets and all maximal regular coplanar lattices

The All Maximal Equally-Spaced Collinear Subset (AMESCS) Problem is defined as follows. Given a set P of n points in a Euclidean space E d , find all maximal equally-spaced collinear subsets of P. An optimal Θ( n 2) time sequential solution to the problem is given in Kahng and Robins (1991). A related problem is the All Maximal Regularly-Spaced Subsets (AMRSS) Problem, defined as follows. Given a set P of n points in E d , find all maximal regularly-spaced coplanar subsets of P. An optimal O( n 3) time sequential solution to the problem is given in Kahng and Robins (1991). In this paper, we consider parallel solutions to the AMESCS and AMRSS Problems. Optimal sequential running times of O( n 2) and O( n 3), respectively, make parallel solutions of these problems desirable of large n. While the optimal sequential algorithms of Kahng and Robins (1991) are dominated by repetitions of a procedure that requires Θ( n) time per repetition, and appears inherently sequential, the algorithms we give are quite different. Our parallel algorithms solve both of these problems to within a logarithmic factor of optimality on the Arbitrary CRCW PRAM, and in optimal time on the mesh-connected computer.

An efficient parallel sorting algorithm

We consider the problem of sorting n numbers that contain only k distinct values. We present a randomized arbitrary CRCW PRAM algorithm that runs in O(log n) time using (n log k)log n processors. The same algorithm runs in O((log n)log log n) time with a total work of O(n (log k)1 + ε) for any fixed ε < 0. All the stated bounds hold with high probability.

Improved algorithms for graph four- connectivity

We present a new algorithm based on open ear decomposition for testing vertex four-connectivity and for finding all separating triplets in a triconnected graph. A sequential implementation of our algorithm runs in O( n 2) time and a parallel implementation runs in O(log 2 n) time using O( n 2) processors on an ARBITRARY CRCW PRAM, where n is the number of vertices in the graph. This improves previous bounds for the problem for both the sequential and the parallel cases. The sequential time bound is the best possible, to within a constant factor, if the input is specified in adjacency matrix form, or if the input graph is dense.