Showing papers on "Spanning tree published in 1986"
TL;DR: This paper uses F-heaps to obtain fast algorithms for finding minimum spanning trees in undirected and directed graphs and can be extended to allow a degree constraint at one vertex.
Abstract: Recently, Fredman and Tarjan invented a new, especially efficient form of heap (priority queue). Their data structure, theFibonacci heap (or F-heap) supports arbitrary deletion inO(logn) amortized time and other heap operations inO(1) amortized time. In this paper we use F-heaps to obtain fast algorithms for finding minimum spanning trees in undirected and directed graphs. For an undirected graph containingn vertices andm edges, our minimum spanning tree algorithm runs inO(m logβ (m, n)) time, improved fromO(mβ(m, n)) time, whereβ(m, n)=min {i|log(i)
n ≦m/n}. Our minimum spanning tree algorithm for directed graphs runs inO(n logn + m) time, improved fromO(n log n +m log log log(m/n+2)
n). Both algorithms can be extended to allow a degree constraint at one vertex.
543 citations
TL;DR: The essence of the algorithm is to find a generalized minimum spanning tree of a graph in one coherent phase as opposed to the previous multiple steps approach.
Abstract: We present an algorithm for finding a Steiner tree for a connected, undirected distance graph with a specified subset S of the set of vertices V. The set V-S is traditionally denoted as Steiner vertices. The total distance on all edges of this Steiner tree is at most 2(1−1/l) times that of a Steiner minimal tree, where l is the minimum number of leaves in any Steiner minimal tree for the given graph. The algorithm runs in O(¦E¦log¦V¦) time in the worst case, where E is the set of all edges and V the set of all vertices in the graph. It improves dramatically on the best previously known bound of O(¦S¦¦V¦2), unless the graph is very dense and most vertices are Steiner vertices. The essence of our algorithm is to find a generalized minimum spanning tree of a graph in one coherent phase as opposed to the previous multiple steps approach.
196 citations
DOI•
01 Apr 1986TL;DR: In this paper, the image is mapped onto a weighted graph and a spanning tree of this graph is used to describe regions or edges in the image, and edge detection is shown to be a dual problem to segmentation.
Abstract: The paper describes methods of image segmentation and edge detection based on graph-theoretic representations of images. The image is mapped onto a weighted graph and a spanning tree of this graph is used to describe regions or edges in the image. Edge detection is shown to be a dual problem to segmentation. A number of methods are developed, each providing a different segmentation or edge detection technique. The simplest of these uses the shortest spanning tree (SST), a notion that forms the basis of the other improved methods. These further methods make use of global pictorial information, removing many of the problems of the SST segmentation in its simple form and of other pixel linking algorithms. An important feature in all of the proposed methods is that regions may be described in a hierarchical way.
179 citations
TL;DR: This paper considers ways of deciding which vertices of V are in V″ and compares the performance of various heuristic algorithms.
Abstract: Given a graph G = (V, E), finding the Steiner tree in G for some set of special vertices V′ ⊂ V″, is equivalent to finding the minimum spanning tree in the subgraph of G induced by V′ ∪ V″, where V″ is the set of Steiner vertices. In this paper, we consider ways of deciding which vertices of V are in V″ and compare the performance of various heuristic algorithms.
167 citations
TL;DR: A new approach for studying order and disorder in sets of particles is developed, based on a graph constructed from the set of points locating the positions of the particles, called the minimal spanning tree, which allows it to deduce two parameters, namely, the average edge length and the standard deviation.
Abstract: We develop a new approach for studying order and disorder in sets of particles. This approach is based on a graph constructed from the set of points locating the positions of the particles. This graph, which is called the minimal spanning tree, allows us to deduce two parameters, namely, the average edge length $m$ and the standard deviation $\ensuremath{\sigma}$, which are characteristic of the repartition to be studied. The method is applied to particles of an aggregated lithium thin film deposited on a dielectric substrate. These particles are found to be partially ordered. The use of a diagram involving both $m$ and $\ensuremath{\sigma}$ turns out to be a powerful tool for the determination of the degree of order in very various systems.
112 citations
TL;DR: This work shows that many of the formulas for determiningt(G), the number of spanning trees of any graphG, in terms of a determinant, can be simply derived from known properties of Chebyshev polynomials.
Abstract: The Kirchhoff Matrix Tree Theorem provides an efficient algorithm for determiningt(G), the number of spanning trees of any graphG, in terms of a determinant. However for many special classes of graphs, one can avoid the evaluation of a determinant, as there are simple, explicit formulas that give the value oft(G). In this work we show that many of these formulas can be simply derived from known properties of Chebyshev polynomials. This is demonstrated for wheels, fans, ladders, Moebius ladders, and squares of cycles. The method is then used to derive a new spanning tree formula for the complete prismR
n
(m) =K
m
×C
n
. It is shown that
$$2^{\left( {\begin{array}{*{20}c} n \\ 2 \\ \end{array} } \right)\left( {1 - \frac{1}{{r - 1}} + o\left( 1 \right)} \right)} $$
whereT
n
(x) is then
th order Chebyshev polynomial of the first kind.
99 citations
01 Jan 1986
TL;DR: This paper describes an efficient implementation of the network simplex method for solving large sparse minimum-cost network flow problems which employs an initial spanning tree of all artificial edges, a gradual penalty method for reducing infeasibilities and a sample pricing strategy which does not require adjacency-ordered edge lists.
Abstract: This paper describes an efficient implementation of the network simplex method for solving large sparse minimum-cost network flow problems. This is a single-phase implementation which employs an initial spanning tree of all artificial edges, a gradual penalty method for reducing infeasibilities and a sample pricing strategy which does not require adjacency-ordered edge lists. Data structures, algorithmic details and computational experience with a set of generated problems are presented. For the problems tested, the present implementation is found to be more efficient than other available implementations of the network simplex and primal-dual methods.
92 citations
TL;DR: A family of extremely simple bijections are constructed that yield Cayley's famous formula for counting trees and allow the calculation of explicit formulas for the expected number of various statistics on Cayley trees.
62 citations
TL;DR: This paper presents an unbounded-parallel algorithm for performing a depth-first search of a planar undirected graph that uses n processors and executes in O(\log ^3 n)-time.
Abstract: This paper presents an unbounded-parallel algorithm for performing a depth-first search of a planar undirected graph. The algorithm uses $O(n^4 )$ processors and executes in $O(\log ^3 n)$-time. It had previously been conjectured that the problem of computing a depth-first spanning tree was inherently sequential.
55 citations
TL;DR: This work considers as objective function the maximum difference between the weights of components in a spanning tree and presents an efficient algorithm to achieve the optimum or prove that the problem is NP-hard.
41 citations
TL;DR: In this article, it was shown that the spanning tree number t of a connected multigraph has a unique factorization, t = t_1 t_2 \cdots t_m, such that t_i is a multiple of t,i = 1,2, m -1,m -1$ and such that for every Abelian group A the group $B ( A )$ of bicycles over A is isomorphic to
Abstract: Let G be a connected multigraph and let $( A, + ,0 )$ be any Abelian group. For k an integer, let $A ( k )$ denote the subgroup of A given by $A ( k ) = \{ a \in A | ka = 0 \}$. A bicycle over A is a cycle over A that is also a cocycle. The set $B ( A )$ of bicycles over A determines a group. In this paper we show that the spanning tree number t of G has a unique factorization $t = t_1 t_2 \cdots t_m $ such that $t_i $ is a multiple of $t_{i + 1} ,i = 1,2, \cdots ,m - 1$ and such that for every Abelian group A the group $B ( A )$ of bicycles over A is isomorphic to $A ( t_1 ) \times A ( t_2 ) \times \cdots \times A ( t_m )$. Using this result we obtain a number of results on the spanning tree number including two formulae for the spanning tree number.
TL;DR: An asynchronous algori thm is described which determines a spanning tree of the graph and can be favourably compared to the one of Gallagher et al.
TL;DR: In this paper, a parallel algorithm for updating a minimum spanning tree requires O(log n) time and O(n 2 ) processors, which is the same as the algorithm described in this paper.
TL;DR: In this paper a new enumeration algorithm based on the idea of contractions of the graph is presented and computational analysis indicates that the algorithm requires less computation time than any other of the previously best-known algorithms.
Abstract: Enumeration of spanning trees of an undirected graph is one of the graph problems that has received much attention in the literature. In this paper a new enumeration algorithm based on the idea of contractions of the graph is presented. The worst-case time complexity of the algorithm isO(n+m+nt) wheren is the number of vertices,m the number of edges, andt the number of spanning trees in the graph. The worst-case space complexity of the algorithm isO(n2). Computational analysis indicates that the algorithm requires less computation time than any other of the previously best-known algorithms.
01 Nov 1986
TL;DR: This paper gives a polynomial-time heuristic algorithm that produces a Steiner tree of expected length some fraction shorter than a minimum spanning tree, and proves the expected value of the minimum number of Steiner points in a shortest rectilinear Steiner Tree grows linearly withN.
Abstract: In recent years, researchers have proven many theorems of the following form: given points distributed according to a Poisson process with intensity parameterN on the unit square, the length of the shortest spanning tree (rectilinear Steiner tree, traveling salesman tour, or some other functional) on these points is, with probability one, asymptotic to β√N for some constant β (which is presumably different for different functionals). Though these theorems are well understood, very little is known about the constants β. In this paper we prove that the constants in the cases of rectilinear spanning tree and rectilinear Steiner tree do, indeed, differ. This proof is constructive in the sense that we give a polynomial-time heuristic algorithm that produces a Steiner tree of expected length some fraction shorter than a minimum spanning tree. We continue the analysis to prove a second result: the expected value of the minimum number of Steiner points in a shortest rectilinear Steiner tree grows linearly withN.
01 Sep 1986
TL;DR: This paper studies Clark Thompson''s heuristic experimentally and finds that it gives solutions about 9% shorter than minimum spanning trees on medium size problems (40-100 nodes).
Abstract: Clark Thompson recently suggested a very natural "greedy" heuristic for the rectilinear Steiner problem (RSP), analogous to Kruskal''s algorithm for the minimum spanning tree problem. We study this heuristic by comparing the solutions it finds with rectilinear minimum spanning trees. We first prove a theoretical result on instances of RSP consisting of a large number of random points in the unit square. Thompson''s heuristic produces a tree expected length some fraction shorter than a minimum spanning tree. The second part of this paper studies Thompsons''s heuristic experimentally and finds that it gives solutions about 9% shorter than minimum spanning trees on medium size problems (40-100 nodes). this performance is very similar to that of other RSP heuristics described in the literature.
TL;DR: The complexity of finding the best partitioning of the vertices of an undirected graph is analyzed and it is shown that it is NP-complete.
Abstract: The partitioning of the vertices of an undirected graph, in a way that makes its quotient graph a tree, mirrors a way of permuting a square symmetric matrix to allow its factoring with little fil-in. We analyze the complexity of finding the best partitioning and show that it is NP-complete. We also give a new and simpler implementation of an algorithm that finds a maximal quotient tree.
TL;DR: It is shown that the simple random walk on the natural spanning of Z d is recurrent for every d and the asymptotic behaviour of the probability of returning to the origin in n steps is determined.
TL;DR: A parallel algorithm is described for computing the minimum spanning tree of an undirected, connected and weighted graph withn vertices using a shared-memory single-instruction-stream, multiple-data-stream model of computation which does not allow read or write conflicts.
Abstract: A parallel algorithm is described for computing the minimum spanning tree of an undirected, connected and weighted graph withn vertices. We assume a shared-memory single-instruction-stream, multiple-data-stream model of computation which does not allow read or write conflicts. The algorithm is adaptive in the sense that it usesn1−e processors and runs inO(n1+e) time wheree lies between 0 and 1 and depends on the number of available processors. In view of the obvious Ω(n2) lower bound on the number of operations required to compute a minimum spanning tree, the algorithm is also cost-optimal.
15 Jul 1986
TL;DR: A new parallel algorithm for updating the minimum spanning tree of an n-vertex graph following the addition of a new vertex is presented and is superior to known results on this model.
Abstract: A new parallel algorithm for updating the minimum spanning tree of an n-vertex graph following the addition of a new vertex is presented. The algorithm runs in O(log n) time, using O(n) processors on a concurrent-read-exclusive-write parallel random access machine. The algorithm uses a divide-and-conquer strategy, and is superior to known results on this model, that either obtain O(log n) time performance using O(n2) processors, or employ O(n) processors but have a time complexity of O (log2 n).
01 Jan 1986
TL;DR: In [L 85a] a hierarchical graph model is defined that allows the exploitation of the hierarchy for the more efficient solution of graph problems on very large graphs.
Abstract: In [L 85a] a hierarchical graph model is defined that allows the exploitation of the hierarchy for the more efficient solution of graph problems on very large graphs. The model is motivated by applications in the design of VLSI circuits.
TL;DR: A divide-and-conquer algorithm to construct minimal spanning trees out of a set of points in two dimensions based upon the concept of Voronoi diagrams is presented.
Abstract: We shall present a divide-and-conquer algorithm to construct minimal spanning trees out of a set of points in two dimensions. This algorithm is based upon the concept of Voronoi diagrams. If implemented in parallel, its time complexity isO(N) and it requiresO(logN) processors whereN is the number of input points.
TL;DR: An O(log n) step algorithm for solving the root-shifting problem using n3 processors on a parallel computer which does not permit concurrent writes but allows concurrent reads is presented.
TL;DR: In this paper, a directed spanning tree is proposed for determinantal formulas in the asymmetric zero-pattern case, where the determinant of a diagonal and of a triangular matrix are both the product of the diagonal entries.
TL;DR: The machine model that is concerned with is a tree-structured parallel computer which combines SIMD and systolic computers in a treelike manner and has an O(n2dp + n log p)-time algorithm for finding fundamental cycles and bridges in a connected, undirected graph G with n vertices.
TL;DR: It is shown that every planar graph has a minimal path algorithm presentation but that some graphs have no minimal path algorithms presentations, and the notion of a shortest distance algorithm graph is introduced.
Abstract: In 1981 two notions of effective presentation of countable connected graphs were formulated by J. C. E. Dekker—namely, edge recognition algorithm graphs and minimal path algorithm graphs. In this paper we show that every planar graph has a minimal path algorithm presentation but that some graphs have no minimal path algorithm presentations. We introduce the notion of a shortest distance algorithm graph, show that it lies strictly between the two notions of Dekker, and show that every graph has a shortest distance algorithm presentation. Finally, in contrast to Dekker's result about minimal path algorithm graphs, we produce a shortest distance algorithm graph which has no spanning tree which is an edge recognition algorithm graph.
TL;DR: A new algorithm for the reliability evaluation of computer communication networks is proposed, which is based on the sharp operation on cubes, which avoids the shortcomings in Aggarwal and Rei's method and therefore reduces the storage and computation time significantly.
TL;DR: This work provides an efficient 2- quasi-greedy algorithm where a minimum weight base is constrained to have a fixed number of elements from two disjoint sets and gives theorems making it possible to jump over certain adjacent states, further increasing efficiency.
01 Jan 1986
TL;DR: A divide-and-conquer algorithm to construct minimal spanning trees out of a set of points in two dimensions based upon the concept of Voronoi diagrams is presented.
Abstract: We shall present a divide-and-conquer algorithm to construct minimal spanning trees out of a set of points in two dimensions. This algorithm is based upon the concept of Voronoi diagrams. If implemented in parallel, its time complexity is O(N) and it requires O(logN) processors where N is the number of input points.
TL;DR: In this paper an algorithm, named BREADTH, also computing breadth first spanning trees, is proposed, the complexity of which is O(log2 n) using O{n 3/logn) processors, and an efficient parallel algorithm,named BreadTHFOREST, is presented, which generalizes algorithm B BreadTH.
Abstract: Ghosh and Bhattacharjee propose [2] (Intern. J. Computer Math., 1984, Vol. 15, pp. 255-268) an algorithm of determining breadth first spanning trees for graphs, which requires that the input graphs contain some vertices, from which every other vertex in the input graph can be reached. These vertices are called starting vertices. The complexity of the GB algorithm is O(log2 n) using O{n 3) processors. In this paper an algorithm, named BREADTH, also computing breadth first spanning trees, is proposed. The complexity is O(log2 n) using O{n 3/logn) processors. Then an efficient parallel algorithm, named- BREADTHFOREST, is proposed, which generalizes algorithm BREADTH. The output of applying BREADTHFOREST to a general graph, which may not contain any starting vertices, is a breadth first spanning forest of the input graph. The complexity of BREADTHFOREST is the same as BREADTH.