Parallel Computations of Levenshtein Distances

This chapter discusses parallel solutions for the string editing problem introduced in Chapter 5. The model of computation used is the synchronous, shared - memory machine referred to as PRAM and discussed also earlier in this book. The algorithms of this chapter are based on the CREW and CRCW variants of the PRAM. In the CREW - PRAM model of parallel computation concurrent reads are allowed but no two processors can simultaneously attempt to write in the same memory location (even if they are trying to write the same thing). The CRCW - PRAM differs from the CREW - PRAM in that it allows many processors to attempt simultaneous writes in the same memory location: in any such common-write contest, only one processor succeeds, but it is not known in advance which one. The primary objective of PRAM algorithmic design is to devise algorithms that are both fast and efficient for problems in a particular class called NC. Problems in NC are solvable in O(logo(1) n) parallel time by a PRAM using a polynomial number of processors. In order for an algorithm to be both fast and efficient, the product of its time and processor complexities must fall within a polylog factor of the time complexity of the best sequential algorithm for the problem it solves. This goal has been elusive for many simple problems, such as topological sorting of a directed acyclic graph and finding a breadth-first search tree of a graph, which are trivially in NC. For some other problems in NC, it seems counter-intuitive at first that any fast and efficient algorithm may exist, due to the overwhelming number of simultaneous subproblems that arise at some point of the computation. Such is the case of the string-editing problem. This chapter will show that string editing can be solved in O((log n)2) time and O(n2/ log n) processors on the CREW-PRAM, and in O(log n loglog n) time and O(n2/ loglogn) processors on the CRCW-PRAM. Throughout, it will be convenient to analyze our algorithms using the time and work (i.e., number of operations) complexities.

SEQUENTIAL AND PARALLEL ALGORITHMS FOR THE k CLOSEST PAIRS PROBLEM

International Journal of Computational Geometry & Applications ◽

10.1142/s0218195995000167 ◽

1995 ◽

Vol 05 (03) ◽

pp. 273-288 ◽

Cited By ~ 13

Author(s):

HANS-PETER LENHOF ◽

MICHIEL SMID

Keyword(s):

Decision Tree ◽

Parallel Algorithms ◽

Dimensional Space ◽

Decision Tree Model ◽

Sequential Algorithm ◽

Tree Model ◽

Parallel Time ◽

Parallel Version ◽

Pram Model ◽

Let S be a set of n points in D-dimensional space, where D is a constant, and let k be an integer between 1 and [Formula: see text]. A new and simpler proof is given of Salowe’s theorem, i.e., a sequential algorithm is given that computes the k closest pairs in the set S in O(n log n+k) time, using O(n+k) space. The algorithm fits in the algebraic decision tree model and is, therefore, optimal. Salowe’s algorithm seems difficult to parallelize. A parallel version of our algorithm is given for the CRCW-PRAM model. This version runs in O((log n)2 log log n) expected parallel time and has an O(n log n log log n+k) time-processor product. Finally, actual running times are given of an implementation of our sequential algorithm.

Parallel Algorithms for Listing Well-Formed Parentheses Strings

10.1142/s0129626498000055 ◽

1998 ◽

Vol 08 (01) ◽

pp. 19-28 ◽

Cited By ~ 5

Author(s):

Vincent Vajnovszki ◽

Jean Pallo

Keyword(s):

Parallel Algorithms ◽

Computational Model ◽

Shared Memory ◽

Linear Array ◽

Lexicographic Order ◽

Memory Location ◽

Constant Delay ◽

Crew Pram

We present two cost-optimal parallel algorithms generating the set of all well-formed parentheses strings of length 2n with constant delay for each generated string. In our first algorithm we generate in lexicographic order well-formed parentheses strings represented by bitstrings, and in the second one we use the representation by weight sequences. In both cases the computational model is based on an architecture CREW PRAM, where each processor performs the same algorithm simultaneously on a different set of data. Different processors can access the shared memory at the same time to read different data in the same or different memory locations, but no two processors are allowed to write into the same memory location simultaneously. These results complete a recent parallel generating algorithm for well-formed parentheses strings in a linear array of processors model, due to Akl and Stojmenović.

COMPUTING THE ALL-PAIRS LONGEST CHAINS IN THE PLANE

International Journal of Computational Geometry & Applications ◽

10.1142/s0218195995000155 ◽

1995 ◽

Vol 05 (03) ◽

pp. 257-271 ◽

Cited By ~ 4

Author(s):

MIKHAIL J. ATALLAH ◽

DANNY Z. CHEN

Keyword(s):

Parallel Algorithm ◽

Space Complexity ◽

Sequential Algorithm ◽

Pram Model ◽

The Matrix ◽

Crew Pram ◽

Chain Lengths

Many problems on sequences and on special kinds of graphs involve the computation of longest chains passing points in the plane. Given a set S of n points in the plane, we consider the problem of computing the matrix of longest chain lengths between all pairs of points in S, and the matrix of “parent” pointers that describes the n longest chain trees. We present a simple sequential algorithm for computing these matrices. Our algorithm runs in O(n2) time, and hence is optimal. We also present a rather involved parallel algorithm that computes these matrices in O((log n)2) time using O(n2/log n) processors in the CREW PRAM model. These matrices enable us to report, in O(1) time, the length of a longest chain between any two points in S by using one processor, and the actual chain by using k processors, where k is the number of points of S on that chain. The space complexity of the algorithms is O(n2).

PARALLEL ALGORITHMS FOR HAMILTONIAN 2-SEPARATOR CHORDAL GRAPHS

10.1142/s0129626402000823 ◽

2002 ◽

Vol 12 (01) ◽

pp. 51-64 ◽

Cited By ~ 2

Author(s):

B. S. PANDA ◽

VIJAY NATARAJAN ◽

SAJAL K. DAS

Keyword(s):

Parallel Algorithms ◽

Parallel Algorithm ◽

Hamiltonian Cycle ◽

Chordal Graph ◽

Chordal Graphs ◽

Pram Model ◽

Crew Pram ◽

In this paper we propose a parallel algorithm to construct a one-sided monotone polygon from a Hamiltonian 2-separator chordal graph. The algorithm requires O( log n) time and O(n) processors on the CREW PRAM model, where n is the number of vertices and m is the number of edges in the graph. We also propose parallel algorithms to recognize Hamiltonian 2-separator chordal graphs and to construct a Hamiltonian cycle in such a graph. They run in O( log 2 n) time using O(mn) processors on the CRCW PRAM model and O( log 2 n) time using O(m) processors on the CREW PRAM model, respectively.

Length of Maximal Common Subsequences

DAIMI Report Series ◽

10.7146/dpb.v21i426.6740 ◽

1992 ◽

Vol 21 (426) ◽

Author(s):

Kim Skak Larsen

Keyword(s):

Dynamic Programming ◽

Parallel Algorithm ◽

Linear Time ◽

Programming Approach ◽

Simple Modification ◽

Dynamic Programming Approach ◽

Pram Model ◽

Crew Pram ◽

The Common ◽

The problem of computing the length of the maximal common subsequences of two strings is quite well examined in the sequential case. There are many variations, but the standard approach is to compute the length in quadratic time using dynamic programming. A linear-time parallel algorithm can be obtained via a simple modification of this strategy by letting a linear number of processors sweep through the table created for the dynamic programming approach.However, the contribution of this paper is to show that the problem is in NC. More specifically, we show that the length of the maximal common subsequences of two strings s and t can be computed in time O(log |s| € log |t|) in the CREW PRAM model and in time Theta(min(log |s|, log |t|)) in the COMMON CRCW PRAM model.

Parallelizing an Algorithm for Visibility on Polyhedral Terrain

International Journal of Computational Geometry & Applications ◽

10.1142/s0218195997000065 ◽

1997 ◽

Vol 07 (01n02) ◽

pp. 75-84 ◽

Cited By ~ 2

Author(s):

Y. Ansel Teng ◽

David Mount ◽

Enrico Puppo ◽

Larry S. Davis

Keyword(s):

Parallel Algorithm ◽

Time Complexity ◽

Sequential Algorithm ◽

Work Efficiency ◽

Parallel Complexity ◽

Input And Output ◽

Work Complexity ◽

Pram Model ◽

Crew Pram

The best known output-sensitive sequential algorithm for computing the viewshed on a polyhedral terrain from a given viewpoint was proposed by Katz, Overmars, and Sharir,10 and achieves time complexity O((k + nα(n)) log n) where n and k are the input and output sizes respectively, and α() is the inverse Ackermann's function. In this paper, we present a parallel algorithm that is based on the work mentioned above, and achieves O( log 2n) time complexity, with work complexity O((k + nα(n)) log n) in a CREW PRAM model. This improves on previous parallel complexity while maintaining work efficiency with respect to the best sequential complexity known.

SUB-LOGARITHMIC ALGORITHMS FOR THE LARGEST EMPTY RECTANGLE PROBLEM

10.1142/s0129626493000113 ◽

1993 ◽

Vol 03 (01) ◽

pp. 79-85

Author(s):

STEPHAN OLARIU ◽

WENHUI SHEN ◽

LARRY WILSON

Keyword(s):

Parallel Algorithms ◽

Erew Pram ◽

Pram Model ◽

The Common ◽

Crcw Pram ◽

Natural Way

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 TREE RANKING IS IN $\mathcal{NC}$

10.1142/s0129626492000155 ◽

1992 ◽

Vol 02 (01) ◽

pp. 31-41 ◽

Cited By ~ 12

Author(s):

PILAR DE LA TORRE ◽

RAYMOND GREENLAW ◽

TERESA M. PRZYTYCKA

Keyword(s):

General Problem ◽

Sequential Algorithm ◽

Natural Numbers ◽

Ranking Problem ◽

Crew Pram ◽

Optimal Tree ◽

Optimal Ranking

This paper places the optimal tree ranking problem in [Formula: see text]. A ranking is a labeling of the nodes with natural numbers such that if nodes u and v have the same label then there exists another node with a greater label on the path between them. An optimal ranking is a ranking in which the largest label assigned to any node is as small as possible among all rankings. An O(n) sequential algorithm is known. Researchers have speculated that this problem is P-complete. We show that for an n-node tree, one can compute an optimal ranking in O( log n) time using n2/ log n CREW PRAM processors. In fact, our ranking is super critical in that the label assigned to each node is absolutely as small as possible. We achieve these results by showing that a more general problem, which we call the super critical numbering problem, is in [Formula: see text]. No [Formula: see text] algorithm for the super critical tree ranking problem, approximate or otherwise, was previously known; the only known [Formula: see text] algorithm for optimal tree ranking was an approximate one.

A SIMPLE PARALLEL ALGORITHM FOR THE SINGLE FUNCTION COARSEST PARTITION PROBLEM

10.1142/s0129626494000405 ◽

1994 ◽

Vol 04 (04) ◽

pp. 437-445 ◽

Cited By ~ 1

Author(s):

CLIVE N. GALLEY ◽

COSTAS S. ILIOPOULOS

Keyword(s):

Parallel Algorithm ◽

Parallel Computation ◽

Simple Algorithm ◽

Partition Problem ◽

Pram Model ◽

Single Function ◽

This paper shows a simple algorithm for solving the single function coarsest partition problem on the CRCW PRAM model of parallel computation using O(n) processors in O( log n) time with O(n1+ε) space.

Area Optimization of Slicing Floorplans in Parallel

VLSI Design ◽

10.1155/1994/63707 ◽

1994 ◽

Vol 2 (2) ◽

pp. 143-156

Author(s):

Cheng-Hsi Chen ◽

Ioannis G. Tollis

Keyword(s):

Parallel Algorithms ◽

Parallel Algorithm ◽

Shared Memory ◽

Distributed System ◽

Sequential Algorithm ◽

Area Optimization

We first present a parallel algorithm for finding the optimal implementations for the modules of a slicing floorplan that respects a given slicing tree. The algorithm runs in O(n) time and requires O(n) processors, where n is the number of modules. It is based on a new O(n2) sequential algorithm for solving the above problem. We then present a parallel algorithm for finding a set of optimal implementations for a slicing floorplan whose corresponding slicing tree has height O(logn). This algorithm runs in O(n) time using O(logn) processors. Our parallel algorithms do not need shared memory and can be implemented in a distributed system.