Linear Time Sequential Algorithm Research Articles

Fast computation of small cuts via cycle space sampling

We describe a new sampling-based method to determine cuts in an undirected graph. For a graph ( V , E ), its cycle space is the family of all subsets of E that have even degree at each vertex. We prove that with high probability, sampling the cycle space identifies the cuts of a graph. This leads to simple new linear-time sequential algorithms for finding all cut edges and cut pairs (a set of 2 edges that form a cut) of a graph. In the model of distributed computing in a graph G = ( V , E ) with O (log | V |)-bit messages, our approach yields faster algorithms for several problems. The diameter of G is denoted by D , and the maximum degree by Δ. We obtain simple O ( D )-time distributed algorithms to find all cut edges, 2-edge-connected components, and cut pairs, matching or improving upon previous time bounds. Under natural conditions these new algorithms are universally optimal—that is, a Ω( D )-time lower bound holds on every graph. We obtain a O ( D +Δ/log |V|)-time distributed algorithm for finding cut vertices; this is faster than the best previous algorithm when Δ, D = O (√| V |). A simple extension of our work yields the first distributed algorithm with sub-linear time for 3-edge-connected components. The basic distributed algorithms are Monte Carlo, but they can be made Las Vegas without increasing the asymptotic complexity. In the model of parallel computing on the EREW PRAM, our approach yields a simple algorithm with optimal time complexity O (log V ) for finding cut pairs and 3-edge-connected components.

An efficient algorithm for constructing Hamiltonian paths in meshes

This paper presents an efficient linear-time sequential algorithm for constructing Hamiltonian paths between two given vertices in meshes with horizontal size m and vertical size n. The algorithm first partitions the given mesh into a number of submeshes in constant steps, and then constructs a Hamiltonian cycle or path in each submesh and combines them together to become a complete Hamiltonian path in mn steps. Our algorithm has improved the previous algorithm [6] by reducing the number of partition steps from O( m+ n) to only a constant. Moreover, we show that our algorithm can be optimally parallelized to obtain a constant-time parallel algorithm on the weakest parallel machine without need of inter-processor communication, while this cannot be achieved for the previous algorithm.

The optimal sequential and parallel algorithms to compute all hinge vertices on interval graphs

If the distance between two vertices becomes longer after the removal of a vertexu, thenu is called a hinge vertex. In this paper, a linear time sequential algorithm is presented to find all hinge vertices of an interval graph. Also, a parallel algorithm is presented which takesO(n/P + logn) time usingP processors on an EREW PRAM.

On testing consecutive-ones property in parallel

The consecutive-ones property problem has many important applications in the field of discrete algorithms, including the physical mapping problem in computational molecular biology. A (0, 1)-matrix is said to satisfy the consecutive-ones property if there is a permutation of the rows of the matrix such that in each column all non-zero entries are adjacent. The problem of determining such a permutation, if one exists, is the consecutive-ones property problem. The classic algorithm for solving this problem is a linear time sequential algorithm of Booth and Lueker (1976) which is known to be based on the PQ-tree data structure. In this paper we present a new algorithm for this problem using a divide-and-conquer method that employs a graph-theoretic data structure known as Tutte decomposition, i.e., decomposition of graphs into 3-connected components. Our algorithm enjoys the property that it efficiently parallelizes using the standard PRAM parallel computational model, while avoiding the complex implementations associated with PQ-trees. Our algorithm is more work efficient than previous parallel solutions, improving on the known processor bounds.

An optimal EREW PRAM algorithm for minimum spanning tree verification

We present a deterministic parallel algorithm on the EREW PRAM model to verify a minimum spanning tree of a graph. The algorithm runs on a graph with n vertices and m edges in O( log n) time and O( m + n) work. The algorithm is a parallelization of King's linear time sequential algorithm for the problem.

Optimal algorithms for the single and multiple vertex updating problems of a minimum spanning tree

The vertex updating problem for a minimum spanning tree (MST) is defined as follows: Given a graphG=(V, E G) and an MSTT forG, find a new MST forG to which a new vertexz has been added along with weighted edges that connectz with the vertices ofG. We present a set of rules that produce simple optimal parallel algorithms that run inO(lgn) time usingn/lgn EREW PRAM processors, wheren=¦V¦. These algorithms employ any valid tree-contraction schedule that can be produced within the stated resource bounds. These rules can also be used to derive simple linear-time sequential algorithms for the same problem. The previously best-known parallel result was a rather complicated algorithm that usedn processors in the more powerful CREW PRAM model. Furthermore, we show how our solution can be used to solve the multiple vertex updating problem: Update a given MST whenk new vertices are introduced simultaneously. This problem is solved inO(lgk·lgn) parallel time using (k·n)/(lgk·lgn) EREW PRAM processors. This is optimal for graphs having Ω (kn) edges.

Edge-Coloring Partialk-Trees

Many combinatorial problems can be efficiently solved for partialk-trees (graphs of treewidth bounded byk). The edge-coloring problem is one of the well-known combinatorial problems for which no efficient algorithms were previously known, except a polynomial-time algorithm of very high complexity. This paper gives a linear-time sequential algorithm and an optimal parallel algorithm which find an edge-coloring of a given partialk-tree with the minimum number of colors for fixedk.

Optimal parallel algorithms for rectilinear link-distance problems

We provide optimal parallel solutions to several link-distance problems set in trapezoided rectilinear polygons. All our main parallel algorithms are deterministic and designed to run on the exclusive read exclusive write parallel random access machine (EREW PRAM). LetP be a trapezoided rectilinear simple polygon withn vertices. InO(logn) time usingO(n/logn) processors we can optimally compute:1.Minimum rectilinear link paths, or shortest paths in theL1 metric from any point inP to all vertices ofP.2.Minimum rectilinear link paths from any segment insideP to all vertices ofP.3.The rectilinear window (histogram) partition ofP.4.Both covering radii and vertex intervals for any diagonal ofP.5.A data structure to support rectilinear link-distance queries between any two points inP (queries can be answered optimally inO(logn) time by uniprocessor). Our solution to 5 is based on a new linear-time sequential algorithm for this problem which is also provided here. This improves on the previously best-known sequential algorithm for this problem which usedO(n logn) time and space.5 We develop techniques for solving link-distance problems in parallel which are expected to find applications in the design of other parallel computational geometry algorithms. We employ these parallel techniques, for example, to compute (on a CREW PRAM) optimally the link diameter, the link center, and the central diagonal of a rectilinear polygon.

THE PARALLEL ALGORITHMS FOR DETERMINING EDGE-PACKING AND EFFICIENT EDGE DOMINATING SETS IN INTERVAL GRAPHS

Recently, it has been shown that resource allocation problems in parallel processing systems can be viewed as edge domination problems in graphs. Other applications of edge domination include encoding theory and network routing problems. In a graph G = (V,E) and edge (u,v) ∈ E is said to dominate itself and any edge (u,x) or (v,x) where x ∈ V. An Edge-Packing (EP) in a graph G is a set of edges (B), B CE such that no edge in E is dominated by more than one edge of B. A subset of edges E’ C E is called an Efficient Edge Domination (EED) set for the graph G if all edges in E are dominated by exactly one edge of E’. The EED problem for general graph is NP-complete. For the series parallel graph a linear time sequential algorithm is available. In this paper, a linear time sequential algorithm is presented to find EP for a weighted interval graph. Parallel algorithms are also presented to find EP for weighted and unweighted interval graphs. For the weighted case, the proposed parallel algorithm takes O(log2n) ...

On Finding Minimal Two-Connected Subgraphs

We present efficient parallel algorithms for finding a minimal 2-edge-connected spanning subgraph of a 2-edge-connected graph and finding a minimal biconnected spanning subgraph of a biconnected graph. The parallel algorithms run in polylog time using a linear number of PRAM processors. We also give linear time sequential algorithms for minimally augmenting a spanning tree into a 2-edge-connected or biconnected graph using edges from the original graph.

Finding the closed partition of a planar graph

In this paper we consider the problem of finding aclosed partition in a directed graph. This problem has applications in concurrent probabilistic program verification. The best sequential algorithm known for this problem runs inO(mn) time wherem is the number of directed edges andn is the number of vertices in the given digraph. In this paper we present a linear-time sequential algorithm to solve the closed partition problem for planar digraphs that arecompact. We then build on this algorithm to obtain an O(n1.5)-time sequential algorithm to solve the closed partition problem for a general planar digraph.

Recognition algorithm for intersection graphs of edge disjoint paths in a tree

We present several characterizations of intersection graphs of edge-disjoint paths in a tree. We suggest a linear time sequential algorithm and a parallel NC algorithm for recognition and for construction of an intersection model for these graphs.

Towards overcoming the transitive-closure bottleneck: Efficient parallel algorithms for planar digraphs

There are linear-time sequential algorithms for many fundamental problems related to digraph reachability. In contrast, the best parallel algorithms known for these problems, although fast, require a great many processors and, hence, require much more computation overall than the sequential algorithms. This contrast reflects a seemingly unavoidable reliance on transitive closure techniques in parallel algorithms for digraph reachability. To further understanding of the nature of the bottleneck, we present a collection of polylog-time reductions among reachability problems. These reductions use only linear processors and work for general graphs. Futhermore, for planar digraphs, we give polylog-time algorithms for the following problems: (1) directed ear decomposition, (2) topological ordering, (3) digraph reachability, (4) descendant counting, and (5) depth-first search. Our new algorithms use only a linear number of processors, and, hence, are the first to be within a polylog factor of optimal in their use of parallelism.

Tight complexity bounds for term matching problems

In this paper we study the sequential and parallel complexity of various important term matching problems. These problems occur frequently in applications such as term rewriting, functional programming, and logic programming. First, we obtain non-trivial lower bounds on the parallel complexity of the (uninterpreted) term matching problem. We also establish the tightness of these bounds for some representations and several models. We then characterize completely the sequential complexity of associative and commutative matching when the number of occurrences of variables is varied. Specifically, we show that even if each variable is restricted to at most two occurrences in the terms, both associative matching and commutative matching are NP-complete. Interestingly, for the important restriction of boolean terms we show that commutative matching is NP-complete whereas associative matching has a linear time sequential algorithm. For linear terms, we significantly improve the existing upper bound for associative-commutative matching, and present a new algorithm for associative matching. Designing direct parallel algorithms for associative-commutative matching of linear terms appears to be a difficult task. Despite this we have been able to resolve questions about the parallel complexity of these problems using complexity-theoretic techniques. Finally, an interesting consequence of the research reported here is the demonstration of a tighter relationship between associative-commutative matching for linear terms and bipartite matching on both sequential and parallel models.

Processor Efficient Parallel Algorithms for the Two Disjoint Paths Problem and for Finding a Kuratowski Homeomorph

The authors give a parallel algorithm for finding vertex disjoint $s_1 ,t_1 $ and $s_2 ,t_2 $ paths in an undirected graph G. An important step in solving the general problem is solving the planar case. A new structural property yields the parallelization, as well as a simpler linear-time sequential algorithm for this case. The algorithm is extended to the nonplanar case by giving a parallel algorithm for finding a Kuratowski homeomorph, and, in particular, a homeomorph of $K_{3,3} $, in a nonplanar graph. The algorithms are processor efficient; in each case, the processor-time product of the algorithms is within a polylogarithmic factor of the best-known sequential algorithm.

A note on the reconstruction of a binary tree from its traversals

We present a linear-time sequential algorithm for the construction of a binary tree, given its preorder and inorder traversals. The algorithm leads to an optimal O(log n) time parallel algorithm on the EREW PRAM model, where n is the number of nodes in the tree.

The complexity of circuit value and network stability

We develop a method for nontrivially restricting fanout in a circuit. We study the complexity of the circuit value problem and a new problem, network stability, when fanout is limited. This leads to new classes of problems within P . We conjecture that the new classes are different from P and incomparable to NC . One of these classes, CC . contains several natural complete problems, including circuit value for comparator circuits, lex-first maximal matching, and problems related to stable marriage and stable roommates. When fanout is appropriately limited, we obtain positive results: a parallel algorithm for circuit value that runs in time about the square root of the number of gates, a linear-time sequential algorithm for network stability, and logspace reductions between circuit value and network stability.

Bisections and ham-sandwich cuts of convex polygons and polyhedra

We present a linear time sequential algorithm for finding a straight line that bisects two given disjoint convex polygons. The solution can be generalized to other measures (for instance, perimeter) and other proportions of cutting. Also, the problem is studied in three dimensional space: find a plane that cuts each of three given disjoint convex polyhedra into two parts of equal volume.

Fast algorithms for edge-coloring planar graphs

We present two algorithms which color edges of every planar graph G with max( Δ( G), 19) colors. Therefore both algorithms produce an optimal coloring if Δ( G) ≥ 19. The first one is a linear-time sequential algorithm. The second one is a parallel EREW PRAM algorithm which runs in O(log 2 n) time using O( n) processors. Both algorithms are based on reduction techniques analogous to techniques used previously for vertex coloring, and both improve the best known sequential and parallel algorithms. The results are generalized to constant-genus graphs.

Finding small simple cycle separators for 2-connected planar graphs

We show that every 2-connected triangulated planar graph with n vertices has a simple cycle C of length at most 2√2 · n which separates the interior vertices A from the exterior vertices B such that neither A nor B contain more than 2 3n vertices. The method also gives a linear time sequential algorithm for finding this simple cycle and an NC parallel algorithm. In general, if the maximum face size is d then we exhibit a cycle C as above of size at most 2√ d · n.