CREW PRAM Model Research Articles

Constrained read-once refutations in UTVPI constraint systems: A parallel perspective

AbstractIn this paper, we analyze two types of refutations for Unit Two Variable Per Inequality (UTVPI) constraints. A UTVPI constraint is a linear inequality of the form: $a_{i}\cdot x_{i}+a_{j} \cdot x_{j} \le b_{k}$ , where $a_{i},a_{j}\in \{0,1,-1\}$ and $b_{k} \in \mathbb{Z}$ . A conjunction of such constraints is called a UTVPI constraint system (UCS) and can be represented in matrix form as: ${\bf A \cdot x \le b}$ . UTVPI constraints are used in many domains including operations research and program verification. We focus on two variants of read-once refutation (ROR). An ROR is a refutation in which each constraint is used at most once. A literal-once refutation (LOR), a more restrictive form of ROR, is a refutation in which each literal ( $x_i$ or $-x_i$ ) is used at most once. First, we examine the constraint-required read-once refutation (CROR) problem and the constraint-required literal-once refutation (CLOR) problem. In both of these problems, we are given a set of constraints that must be used in the refutation. RORs and LORs are incomplete since not every system of linear constraints is guaranteed to have such a refutation. This is still true even when we restrict ourselves to UCSs. In this paper, we provide NC reductions between the CROR and CLOR problems in UCSs and the minimum weight perfect matching problem. The reductions used in this paper assume a CREW PRAM model of parallel computation. As a result, the reductions establish that, from the perspective of parallel algorithms, the CROR and CLOR problems in UCSs are equivalent to matching. In particular, if an NC algorithm exists for either of these problems, then there is an NC algorithm for matching.

Taming the knight's tour: Minimizing turns and crossings

We introduce two new metrics of “simplicity” for knight's tours: the number of turns and the number of crossings. We give a novel algorithm that produces tours with 9.25n+O(1) turns and 12n+O(1) crossings on an n×n board, and we show lower bounds of (6−ϵ)n and 4n−O(1) on the respective problems of minimizing these metrics. Hence, our algorithm achieves approximation ratios of 9.25/6+o(1) and 3+o(1). Our algorithm takes linear time and is fully parallelizable, i.e., the tour can be computed in O(n2/p) time using p processors in the CREW PRAM model. We generalize our techniques to rectangular boards, high-dimensional boards, symmetric tours, odd boards with a missing corner, and tours for (1,4)-leapers. In doing so, we show that these extensions also admit a constant approximation ratio on the minimum number of turns, and on the number of crossings in most cases.

An Efficient Algorithm for the 1D Total Visibility-Index Problem and Its Parallelization

Let T be a terrain and P be a set of points on its surface. An important problem in Geographic Information Science (GIS) is computing the visibility index of a point p on P , that is, the number of points in P that are visible from p . The total visibility-index problem asks for the visibility index of every point in P . We present the first subquadratic-time algorithm to solve the one-dimensional total-visibility-index problem. Our algorithm uses a geometric dualization technique to reduce the problem to a set of instances of the red--blue line segment intersection counting problem, allowing us to find the total visibility-index in O ( n log 2 n ) time. We implement a naive O ( n 2 ) approach and four variations of our algorithm: one that uses an existing red--blue line segment intersection counting algorithm and three new approaches that leverage features specific to our problem. Two of our implementations allow for parallel execution, requiring O (log 2 n ) time and O ( n log 2 n ) work in the CREW PRAM model. We present experimental results for both serial and parallel implementations on synthetic and real-world datasets using two hardware platforms. Results show that all variants of our algorithm outperform the naive approach by several orders of magnitude. Furthermore, we show that our special-case red--blue line segment intersection counting implementations out-perform the existing general-case solution by up to a factor 10. Our fastest parallel implementation is able to process a terrain of more than 100 million vertices in under 3 minutes, achieving up to 85% parallel efficiency using 16 cores.

Algorithms for testing occurrences of length 4 patterns in permutations

In this paper linear time sequential and optimal parallel algorithms for testing pattern involvement for all length 4 permutations are described. This is an improvement as the previous best sequential algorithms, for most of these pattern require $$O(n\log n)$$ time. Our parallel algorithms can be implemented in $$O(\log n)$$ time with $$n/\log n$$ processors on the CREW PRAM model, or alternatively in $$O(\log \log \log n)$$ time with $$n/\log \log \log n$$ processors on a CRCW PRAM PRAM model. Parallel algorithm can also be implemented in constant time with $$n\log ^3 n$$ processors on a CRCW PRAM model. The previous best parallel algorithms were available for only some of these patterns and took $$O(\log n)$$ time with n processors on the CREW PRAM model.

Simpler Sequential and Parallel Biconnectivity Augmentation in Trees

For a connected graph, a vertex separator is a set of vertices whose removal creates at least two components and a minimum vertex separator is a vertex separator of least cardinality. The vertex connectivity refers to the size of a minimum vertex separator. For a connected graph G with vertex connectivity [Formula: see text], the connectivity augmentation refers to a set S of edges whose augmentation to G increases its vertex connectivity by one. A minimum connectivity augmentation of G is the one in which S is minimum. In this paper, we focus our attention on biconnectivity augmentation for trees. Towards this end, we present a new sequential algorithm for biconnectivity augmentation in trees by simplifying the algorithm reported in [1]. The simplicity is achieved with the help of edge contraction tool. This tool helps us in getting a recursive subproblem preserving all connectivity information. Subsequently, we present a parallel algorithm to obtain a minimum biconnectivity augmentation set in trees. Our parallel algorithm essentially follows the overall structure of sequential algorithm. Our implementation is based on CREW PRAM model with [Formula: see text] processors, where [Formula: see text] refers to the maximum degree of a tree. We also show that our parallel algorithm is optimal with a processor-time product of [Formula: see text] where n is the number of vertices of a tree.

New sequential and parallel algorithms for computing the β-spectrum

β-skeletons, prominent members of the neighborhood graph family, have interesting geometric properties and various applications ranging from geographic networks to archeology. This paper focuses on computing the β-spectrum, a labeling of the edges of the Delaunay triangulation, DT(V), which makes it possible to quickly find the lune-based β-skeleton of V for any query value β∈[1,2]. We consider planar n-point sets V with Lp metric, 1<p<∞. We present an O(nlog2⁡n) time sequential, and an O(log4⁡n) time parallel, β-spectrum labeling. We also show a parallel algorithm, which for a given β∈[1,2] finds the lune-based β-skeleton in O(log2⁡n) time. The parallel algorithms use O(n) processors in the CREW-PRAM model.

Application of Fuzzy Optimization to the Orienteering Problem

This paper deals with the orienteering problem (OP) which is a combination of two well-known problems (i.e., travelling salesman problem and the knapsack problem). OP is an NP-hard problem and is useful in appropriately modeling several challenging applications. As the parameters involved in these applications cannot be measured precisely, depicting them using crisp numbers is unrealistic. Further, the decision maker may be satisfied with graded satisfaction levels of solutions, which cannot be formulated using a crisp program. To deal with the above-stated two issues, we formulate thefuzzyorienteering problem (FOP) and provide a method to solve it. Here we state the two necessary conditions of OP of maximizing the total collected score and minimizing the time taken to traverse a path (within the specified time bound) as fuzzy goals and the remaining necessary conditions as crisp constraints. Using the max-min formulation of the fuzzy sets obtained from the fuzzy goals, we calculate the fuzzy decision sets (ZandZ∗) that contain the feasible paths and the desirable paths, respectively, along with the degrees to which they are acceptable. To efficiently solve large instances of FOP, we also present a parallel algorithm on CREW PRAM model.

Parallel Algorithms for Maximal Cliques in Circle Graphs and Unrestricted Depth Search

We present parallel algorithms on the BSP/CGM model, with p processors, to count and generate all the maximal cliques of a circle graph with n vertices and m edges. To count the number of all the maximal cliques, without actually generating them, our algorithm requires O (log p ) communication rounds with O (nm /p ) local computation time. We also present an algorithm to generate the first maximal clique in O (log p ) communication rounds with O (nm /p ) local computation, and to generate each one of the subsequent maximal cliques this algorithm requires O (log p ) communication rounds with O (m /p ) local computation. The maximal cliques generation algorithm is based on generating all maximal paths in a directed acyclic graph, and we present an algorithm for this problem that uses O log (p) communication rounds with O (m /p ) local computation for each maximal path. We also show that the presented algorithms can be extended to the CREW PRAM model.

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.

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.

Coloring permutation graphs in parallel

A coloring of a graph G is an assignment of colors to its vertices so that no two adjacent vertices have the same color. We study the problem of coloring permutation graphs using certain properties of the lattice representation of a permutation and relationships between permutations, directed acyclic graphs and rooted trees having specific key properties. We propose an efficient parallel algorithm which colors an n-node permutation graph in O( log 2 n) time using O(n 2/ log n) processors on the CREW PRAM model. Specifically, given a permutation π we construct a tree T ∗[π] , which we call coloring-permutation tree, using certain combinatorial properties of π. We show that the problem of coloring a permutation graph is equivalent to finding vertex levels in the coloring-permutation tree.

PARALLEL ALGORITHMS FOR HAMILTONIAN 2-SEPARATOR CHORDAL GRAPHS

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.

An Efficient Output-Size Sensitive Parallel Algorithm for Hidden-Surface Removal for Terrains

We describe an efficient parallel algorithm for hidden-surface removal for terrain maps. The algorithm runs in O(log 4 n) steps on the CREW PRAM model with a work bound of O((n+k) \polylog ( n)) where n and k are the input and output sizes, respectively. In order to achieve the work bound we use a number of techniques, among which our use of persistent data structures is somewhat novel in the context of parallel algorithms.

EFFICIENT PARALLEL RANGE SEARCHING AND PARTITIONING ALGORITHMS*

We present an optimal parallel construction of the range tree data structure and use this construction to solve several geometric partitioning problems. In the range tree, we show how to perform a count-mode orthogonal range query in 0(log n) time by a single processor and a report mode orthogonal range query in 0(log n) time using 0(1 + log n) processors, where k is the number of points inside the query range. We consider partitioning problems of the following nature. Given a planar point set S (∣S∣ = ri) a measure μacting on 5 and a pair of values μ1 and μ2,the task is to find a partition of S into two components S1 and S2 (S = S1U S2) such that μ(S1) =μ1 for i=1, 2. We consider several measures like diameter under L∞ and l1 metric; area, perimeter of the smallest enclosing axes-parallel rectangle; and the side length of the smallest enclosing axes-parallel square. All our parallel algorithms foi partitioning problems run in 0(log n) time using 0(n) processors. Our algorithms are designed for the CREW PRAM model of parallel computation.

Coloring permutation graphs in parallel

Abstract — We study the problem of coloring permutations graphs using some properties of the Lattice representation of a permutation and the relationship between permutations and binary search trees. We propose an efficient parallel algorithm which colors a permutation graph in O (log 2 n) time using O (n 2 /logn) processors on the CREW PRAM model, where n is the number of vertices in the permutation graph. Specifically, given a permutation π we construct a tree T ∗ [π], which we call coloring-permutation tree , using certain combinatorial properties of π. We show that the problem of coloring a permutation graph is equivalent to finding vertex levels in the coloring-permutation tree. Our results improve in performance upon the best-known parallel algorithms for the same problem.

Work-time optimal k-merge algorithms on the PRAM

For 2/spl les/k/spl les/n, the k-merge problem is to merge a collection of ksorted sequences of total length n into a new sorted sequence. The k-merge problem is fundamental as it provides a common generalization of both merging and sorting. The main contribution of this work is to give simple and intuitive work-time optimal algorithms for the k-merge problem on three PRAM models, thus settling the status of the k-merge problem. We first prove that /spl Omega/(n log k) work is required to solve the k-merge problem on the PRAM models. We then show that the EREW-PRAM and both the CREW-PRAM and the CRCW require /spl Omega/(log n) time and /spl Omega/(log log n+log k) time, respectively, provided that the amount of work is bounded by O(n log k). Our first k-merge algorithm runs in /spl Theta/(log n) time and performs /spl Theta/(n log k) work on the EREW-PRAM. Finally, we design a work-time optimal CREW-PRAM k-merge algorithm that runs in /spl Theta/(log log n+log k) time and performs /spl Theta/(n log k) work. This latter algorithm is also work-time optimal on the CREW-PRAM model. Our algorithms completely settle the status of the k-merge problem on the three main PRAM models.

Lower Bounds for Randomized Exclusive Write PRAMs

In this paper we study the question: How useful is randomization in speeding up Exclusive Write PRAM computations? Our results give further evidence that randomization is of limited use in these types of computations. First we examine a compaction problem on both the CREW and EREW PRAM models, and we present randomized lower bounds which match the best deterministic lower bounds known. (For the CREW PRAM model, the lower bound is asymptotically optimal.) These are the first nontrivial randomized lower bounds known for the compaction problem on these models. We show that our lower bounds also apply to the problem of approximate compaction. Next we examine the problem of computing boolean functions on the CREW PRAM model, and we present a randomized lower bound which improves on the previous best randomized lower bound for many boolean functions, including the OR function. (The previous lower bounds for these functions were asymptotically optimal, but we improve the constant multiplicative factor.) We also give an alternate proof for the randomized lower bound on PARITY, which was already optimal to within a constant additive factor. Lastly, we give a randomized lower bound for integer merging on an EREW PRAM which matches the best deterministic lower bound known. In all our proofs, we use the Random Adversary method, which has previously only been used for proving lower bounds on models with Concurrent Write capabilities. Thus this paper also serves to illustrate the power and generality of this method for proving parallel randomized lower bounds.

Connected Components inO(log3/2 n) Parallel Time for the CREW PRAM

Finding the connected components of an undirected graphG=(V, E) onn=|V| vertices andm=|E| edges is a fundamental computational problem. The best known parallel algorithm for the CREW PRAM model runs inO(log2n) time usingn2/log2nprocessors. For the CRCW PRAM model, in which concurrent writing is permitted, the best known algorithm runs inO(logn) time using slightly more than (n+m)/lognprocessors. Simulating this algorithm on the weaker CREW model increases its running time toO(log2n). We present here a simple algorithm that runs inO(log3/2n) time usingn+mCREW processors. Finding ano(log2n) parallel connectivity algorithm for this model was an open problem for many years.

Parallelizing an Algorithm for Visibility on Polyhedral Terrain

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.

Optimal parallel verification of minimum spanning trees in logarithmic time

We present the first optimal parallel algorithms for the verification and sensitivity analysis of minimum spanning trees. Our algorithms are deterministic and run inO(logn) time and require linear-work in the CREW PRAM model. These algorithms are used as a subroutine in the linear-work randomized algorithm for finding minimum spanning trees of Cole, Klein, and Tarjan.