CRCW PRAM Algorithm Research Articles

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 two dimensional witness computation

An optimal parallel CRCW-PRAM algorithm to compute witnesses for all non-period vectors of an m1×m2 pattern is given. The algorithm takes O(loglogm) time and does O(m1×m2) work, where m=max{m1,m2}. This yields a work optimal algorithm for 2D pattern matching which takes O(loglogm) preprocessing time and O(1) text processing time.

Optimal Parallel Searching an Array for Certain Repetitions

Abstract Repetitive substructures of two-dimensional arrays have been recently defined and studied in an attempt to parallel some of the analogous developments already known for strings. In the present paper we propose an O (log log n) time O(n3 log n) work optimally fast, optimal parallel CRCW-PRAM algorithm for detecting all repetitions of certain type in an n × n array.

Improving the efficiency of parallel minimum spanning tree algorithms

This paper presents results which improve the efficiency of parallel algorithms for computing the minimum spanning trees. For an input graph with n vertices and m edges our EREW PRAM algorithm runs in O( log n) time with O((m+n) log n ) operations. Our CRCW PRAM algorithm runs in O( log n) time with O((m+n) log log n) operations. We also show that for dense graphs we can achieve O( log n) time with O( n 2) operations on the EREW PRAM.

OPTIMALLY FAST CRCW-PRAM TESTING 2D-ARRAYS FOR EXISTENCE OF REPETITIVE PATTERNS

In classical combinatorial string matching repetitions and other regularities play a central role. Besides their theoretical importance, repetitions in strings have been found relevant to coding and automata theory, formal languages, data compression, and molecular biology. An important motivation for developing a 2D pattern matching theory is seen in its relation with pattern recognition, image processing, computer vision and multimedia. Repetitions in 2D arrays have been defined and classified recently.5 In this paper we present an optimally fast CRCW-PRAM algorithm for testing whether a given n × n array contains repetitions of certain type. The algorithm takes optimal O( log log n) time with [Formula: see text] processors.

Optimal parallel analysis and decomposition of partially occluded strings

This is a theoretical study of partially occluded one-dimensional images. Here, we consider “valid” images composed from a given set of objects, where some objects appearing in the image may be partially obstructed by others. A CRCW PRAM algorithm is presented here for validating a one-dimensional image x of length n over a set of k objects of equal length in O( log logn) time with linear work, where k is a fixed integer.

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.

A nearly optimal parallel algorithm for the Voronoi diagram of a convex polygon

We present a parallel algorithm for the Voronoi diagram of the set of vertices of a convex polygon. The algorithm runs in time O( log n) and uses O( n log log n log n ) processors in the CRCW PRAM model. The concurrent write is used only by an integer sorting subroutine. We also obtain an O( log n)-time and O( n log log n log n )- processor CRCW PRAM algorithm for the construction of the medial axis of a convex polygon. Our algorithms use the solution to the duration-unknown task scheduling problem due to Cole and Vishkin and the optimal parallel algorithm for the convex hull of a polygon due to Wagener. They are randomized in the sense that for any given l > 0 they terminate in time O( log n) with probability greater than 1 − n −1.

Parallel algorithms for the hamiltonian cycle and hamiltonian path problems in semicomplete bipartite digraphs

We give anO(log4n)-timeO(n2)-processor CRCW PRAM algorithm to find a hamiltonian cycle in a strong semicomplete bipartite digraph,B, provided that a factor ofB (i.e., a collection of vertex disjoint cycles covering the vertex set ofB) is computed in a preprocessing step. The factor is found (if it exists) using a bipartite matching algorithm, hence placing the whole algorithm in the class Random-NC.

A work-time optimal algorithm for computing all string covers

In recent study of repetitive structures of strings, generalized notions of periods have been introduced. A typical regularity, the period u of a given string x, grasps the repetitiveness of x since x is a prefix of a string constructed by concatenations of u. A substring w of x is called a cover of x if x can be constructed by concatenations and superpositions of w. The notion “cover” is a generalization of periods in the sense that superpositions as well as concatenations are considered to define it, whereas only concatenations are considered for periods. We consider the all-covers problem, i.e., that of computing all the covers of a given string of length n. We present an optimal O( log log n)-time CRCW PRAM algorithm for the all-covers problem. Since there is an Ω(log log n) lower bound on the time complexity of the all-covers problem, our algorithm is work-time optimal.

An efficient parallel recognition algorithm for bipartite-permutation graphs

We present a parallel recognition algorithm for bipartite-permutation graphs. The algorithm can be executed in O(log n) time on the CRCW PRAM if O(n/sup 3//log n) processors are used, or O(log/sup 2/ n) time on the CREW PRAM if O(n/sup 3//log/sup 2/n) processors are used. Chen and Yesha (1993) have presented another CRCW PRAM algorithm that takes O(log/sup 2/n) time if O(n/sup 3/) processors are used. Compared with Chen and Yesha's algorithm, our algorithm requires either less time and fewer processors on the same machine model, or fewer processors on a weaker machine model. Our algorithm can also be applied to determine if two bipartite-permutation graphs are isomorphic.

Finding all periods and initial palindromes of a string in parallel

An optimalO(log logn)-time CRCW-PRAM algorithm for computing all period lengths of a string is presented. Previous parallel algorithms compute the period only if it is shorter than half of the length of the string. The algorithm can be used to find all initial palindromes of a string in the same time and processor bounds. Both algorithms are the fastest possible over a general alphabet. We derive a lower bound for finding initial palindromes by modifying a known lower bound for finding the period length of a string [9]. Whenp processors are available the bounds become Θ(⌈n/p⌉+log⌈1+p/n⌉2p).

Fast parallel string prefix-matching

An O( log log m) time n log m log log m - processor CRCW-PRAM algorithm for the string prefix-matching problem over general alphabets is presented. The algorithm can also be used to compute the KMP failure function in O( log log m) time on m log m log log m processors. These results improve on the running time of the best previous algorithm for both problems, which was O( log m), while preserving the same number of operations.

SIMPLE DETERMINISTIC AND RANDOMIZED ALGORITHMS FOR LINKED LIST RANKING ON THE EREW PRAM MODEL

An asynchronous, CRCW PRAM (or APRAM) algorithm for linked list ranking, proposed by Martel and Subramonian, performs EO (n log log n) expected work employing [Formula: see text] processors. Motivated by their unique approach, this paper proposes two EREW list ranking algorithms – one deterministic and the other randomized. The deterministic algorithm performs in [Formula: see text] time using p processors, where n≥p log p. Thus, for p= O (n/ log n), it requires O ( log n log log n) time and O (n log log n) work. Although not work-optimal, this algorithm is very simple compared to the known work-optimal (deterministic) EREW algorithms for list ranking and has the added advantage of small constant factors in the time and space requirements. The randomized algorithm follows the same line of approach, but uses randomization in one step to decrease the time complexity, thus improving on the time complexity of the original algorithm. It requires [Formula: see text] expected time, and hence it is an EO ( log n) expected time, work-optimal algorithm employing p= O (n/ log n) processors. Furthermore, the randomized algorithm uses less space than the deterministic algorithm.

Parallel RAM algorithms for factorizing words

An O(log n log log n) CRCW PRAM algorithm using O( n log n ) processors for computing the unique Lyndon factorization of a word of length n over an unbounded alphabet is presented; this improves the bounds given by Apostolico and Crochemore (1989). Moreover, in the case of fixed alphabets the CRCW PRAM algorithm is optimal (linear cost), requiring O(log n) units of time.

A Simpler Parallel Algorithm for Graph Connectivity

Expander graphs are removed from the current best CRCW PRAM algorithm for obtaining connected components of an undirected graph. The new algorithm is also simpler in its structure and results in reasonably small constants.

Testing string superprimitivity in parallel

A string w covers another string z if every symbol of z is within some occurrence of w in z. A string is called superprimitive if it is covered only by itself, and quasiperiodic if it is covered by some shorter string. This paper presents an optimal O(α| z |) log log | z |) time CRCW-PRAM algorithm that tests if a string z is superprimitive, where α( | z |) is the inverse of Ackermann function. An alternative implementation takes O(log log | z |) time using (| z | log | z |)⧸log log | z | processor, and is the fastest possible with this number of processors over a general alphabet.

Optimal Doubly Logarithmic Parallel Algorithms Based On Finding All Nearest Smaller Values

The all nearest smaller values problem is defined as follows. Let A = ( a 1, a 2,..., a n ) be n elements drawn from a totally ordered domain. For each a i , 1 ≤ i ≤ n, find the two nearest elements in A that are smaller than a i (if such exist): the left nearest smaller element a j (with j < i) and the right nearest smaller element a k (with k > i). We give an O(log log n) time optimal parallel algorithm for the problem on a CRCW PRAM. We apply this algorithm to achieve optimal O(log log n) time parallel algorithms for four problems: (i) Triangulating a monotone polygon, (ii) Preprocessing for answering range minimum queries in constant time, (iii) Reconstructing a binary tree from its inorder and either preorder or postorder numberings, (vi) Matching a legal sequence of parentheses. We also show that any optimal CRCW PRAM algorithm for the triangulation problem requires Ω(log log n) time.

Optimal parallel detection of squares in strings

A stringw isprimitive if it is not a power of another string (i.e., writingw =v k impliesk = 1. Conversely,w is asquare ifw =vv, withv a primitive string. A stringx issquare-free if it has no nonempty substring of the formww. It is shown that the square-freedom of a string ofn symbols over an arbitrary alphabet can be tested by a CRCW PRAM withn processors inO(logn) time and linear auxiliary space. If the cardinality of the input alphabet is bounded by a constant independent of the input size, then the number of processors can be reduced ton/logn without affecting the time complexity of this strategy. The fastest sequential algorithms solve this problemO(n logn) orO(n) time, depending on whether the cardinality of the input alphabet is unbounded or bounded, and either performance is known to be optimal within its class. More elaborate constructions lead to a CRCW PRAM algorithm for detecting, within the samen-processors bounds, all positioned squares inx in timeO(logn) and using linear auxiliary space. The fastest sequential algorithms solve this problem inO(n logn) time, and such a performance is known to be optimal.