TRANSITIVE CLOSURE IN PARALLEL ON A LINEAR NETWORK OF PROCESSORS

1992 ◽  
Vol 02 (02n03) ◽  
pp. 195-203
Author(s):  
MICHEL GASTALDO ◽  
MICHEL MORVAN ◽  
J. MIKE ROBSON
Keyword(s):  
Parallel Algorithm ◽  
Directed Graph ◽  
Transitive Closure ◽  
Linear Time ◽  
Linear Network

In this paper, we propose a linear time parallel algorithm (in the number of edges of the transitive closure) that computes the transitive closure of a directed graph on a linear network of n processors. The underlying architecture is a linear network of processors with neighbouring communications, where the number of processors is equal to the number of vertices of the graph.

Two Streamlined Depth-First Search Algorithms

1986 ◽  
Vol 9 (1) ◽  
pp. 85-94
Author(s):  
Robert Endre Tarjan
Keyword(s):  
Directed Graph ◽  
Graph Algorithms ◽  
Undirected Graph ◽  
Linear Time ◽  
Search Algorithms ◽  
Depth First Search ◽  
Time Graph

Many linear-time graph algorithms using depth-first search have been invented. We propose simplified versions of two such algorithms, for computing a bipolar orientation or st-numbering of an undirected graph and for finding all feedback vertices of a directed graph.

Graph matching

2020 ◽  
pp. 291-358
Author(s):  
Rob H. Bisseling
Keyword(s):  
Approximation Algorithm ◽  
Parallel Algorithm ◽  
Graph Matching ◽  
Linear Time ◽  
Total Weight ◽  
Mathematical Representation ◽  
Optimal Weight ◽  
Graph Problems ◽  
Positive Weights ◽  
Local Dominance

This chapter explores parallel algorithms for graph matching. Here, a graph is the mathematical representation of a network, with vertices representing the nodes of the network and edges representing their connections. The edges have positive weights, and the aim is to find a matching with maximum total weight. The chapter first presents a sequential, parallelizable approximation algorithm based on local dominance that guarantees attaining at least half the optimal weight in near-linear time. This algorithm, coupled with a vertex partitioning, is the basis for developing a parallel algorithm. The BSP approach is shown to be especially advantageous for graph problems, both in developing a parallel algorithm and in proving it correct. The basic parallel algorithm is enhanced by giving preference to local matches when breaking ties and by adding a load-balancing mechanism. The scalability of the parallel algorithm is put to the test using graphs of up to 150 million edges.

TWO ALGORITHMS FOR COMPUTING THE EUCLIDEAN DISTANCE TRANSFORM

2001 ◽  
Vol 01 (04) ◽  
pp. 635-645 ◽  
Author(s):  
MARINA L. GAVRILOVA ◽  
MUHAMMAD H. ALSUWAIYEL
Keyword(s):  
Parallel Algorithm ◽  
Euclidean Distance ◽  
Linear Array ◽  
Linear Time ◽  
Sequential Algorithm ◽  
Distance Transform ◽  
Optimal Algorithms ◽  
Euclidean Metric ◽  
Input Size ◽  
Feature Transform

Given an n × n binary image of white and black pixels, we present two optimal algorithms for computing the distance transform and the nearest feature transform using the Euclidean metric. The first algorithm is a fast sequential algorithm that runs in linear time in the input size. The second is a parallel algorithm that runs in O(n2/p) time on a linear array of p processors, p, 1 ≤ p ≤ n.

scholarly journals A Linear Parallel Algorithm to Compute Bisimulation and Relational Coarsest Partitions

2021 ◽  
pp. 115-133
Author(s):  
Jan Martens ◽  
Jan Friso Groote ◽  
Lars van den Haak ◽  
Pieter Hijma ◽  
Anton Wijs
Keyword(s):  
Parallel Algorithm ◽  
Time Complexity ◽  
Linear Time ◽  
Random Access ◽  
Time Algorithm ◽  
Transition System ◽  
Linear Time Algorithm

AbstractThe most efficient way to calculate strong bisimilarity is by finding the relational coarsest partition of a transition system. We provide the first linear-time algorithm to calculate strong bisimulation using parallel random access machines (PRAMs). More precisely, with n states, m transitions and $$| Act |\le m$$ | A c t | ≤ m action labels, we provide an algorithm for $$\max (n,m)$$ max ( n , m ) processors that calculates strong bisimulation in time $$\mathcal {O}(n+| Act |)$$ O ( n + | A c t | ) and space $$\mathcal {O}(n+m)$$ O ( n + m ) . The best-known PRAM algorithm has time complexity $$\mathcal {O}(n\log n)$$ O ( n log n ) on a smaller number of processors making it less suitable for massive parallel devices such as GPUs. An implementation on a GPU shows that the linear time-bound is achievable on contemporary hardware.

scholarly journals Safety in s-t Paths, Trails and Walks

Algorithmica ◽  
2021 ◽  
Author(s):  
Massimo Cairo ◽  
Shahbaz Khan ◽  
Romeo Rizzi ◽  
Sebastian Schmidt ◽  
Alexandru I. Tomescu
Keyword(s):  
Directed Graph ◽  
Data Structures ◽  
Linear Time ◽  
Compact Representation ◽  
Complex Data ◽  
Graph Problems ◽  
The Third ◽  
Natural Generalisation ◽  
Basic Graph ◽  
Time Linear

AbstractGiven a directed graph G and a pair of nodes s and t, an s-tbridge of G is an edge whose removal breaks all s-t paths of G (and thus appears in all s-t paths). Computing all s-t bridges of G is a basic graph problem, solvable in linear time. In this paper, we consider a natural generalisation of this problem, with the notion of “safety” from bioinformatics. We say that a walk W is safe with respect to a set $${\mathcal {W}}$$ W of s-t walks, if W is a subwalk of all walks in $${\mathcal {W}}$$ W . We start by considering the maximal safe walks when $${\mathcal {W}}$$ W consists of: all s-t paths, all s-t trails, or all s-t walks of G. We show that the solutions for the first two problems immediately follow from finding all s-t bridges after incorporating simple characterisations. However, solving the third problem requires non-trivial techniques for incorporating its characterisation. In particular, we show that there exists a compact representation computable in linear time, that allows outputting all maximal safe walks in time linear in their length. Our solutions also directly extend to multigraphs, except for the second problem, which requires a more involved approach. We further generalise these problems, by assuming that safety is defined only with respect to a subset of visible edges. Here we prove a dichotomy between the s-t paths and s-t trails cases, and the s-t walks case: the former two are NP-hard, while the latter is solvable with the same complexity as when all edges are visible. We also show that the same complexity results hold for the analogous generalisations of s-tarticulation points (nodes appearing in all s-t paths). We thus obtain the best possible results for natural “safety”-generalisations of these two fundamental graph problems. Moreover, our algorithms are simple and do not employ any complex data structures, making them ideal for use in practice.

A PARALLEL ALGORITHM FOR ENCLOSED AND ENCLOSING TRIANGLES

1992 ◽  
Vol 02 (02) ◽  
pp. 191-214 ◽  
Author(s):  
SHARAT CHANDRAN ◽  
DAVID M. MOUNT
Keyword(s):  
Parallel Algorithms ◽  
Parallel Algorithm ◽  
Convex Polygon ◽  
Linear Time ◽  
Time Algorithm ◽  
Linear Time Algorithm ◽  
New Techniques ◽  
Crcw Pram

We consider the problems of computing the largest area triangle enclosed within a given n-sided convex polygon and the smallest area triangle which encloses a given convex polygon. We show that these problems are closely related by presenting a single sequential linear time algorithm which essentially solves both problems simultaneously. We also present a cost-optimal parallel algorithm that solves both of these problems in O( log log n) time using n/ log log n processors on a CRCW PRAM. In order to achieve these bounds we develop new techniques for the design of parallel algorithms for computational problems involving the rotating calipers method.

Sign in / Sign up

Export Citation Format

Share Document