Showing papers on "Prim's algorithm published in 1989"

MOD-CHAR: an implementation of Char's spanning tree enumeration algorithm and its complexity analysis

Abstract: Two complexity analyses of MOD-CHAR are presented. It is shown that MOD-CHAR leads to better complexity results for J.P. Char's algorithm than what could be obtained using the straightforward implementation implied in Char's original presentation (see IEEE Trans. Circuit Theory, Vol.15, p.228-38, 1968). The class of graphs for which MOD-CHAR and, hence, Char's algorithm, has linear time complexity per spanning tree generated is identified. This class is more general than the corresponding one identified in R. Jayakumar et al. (see ibid., vol.31, no.10, p.853-60, 1984). Using a result on random graphs, it is proved that for almost all graphs MOD-CHAR has linear worst-case time complexity per spanning tree generated. It is also shown that for any complete graph MOD-CHAR requires, on the average, at most seven computational steps to generate a spanning tree. This result and computational experiences provide evidence to believe that for dense graphs of any order the time complexity of MOD-CHAR is O(t), where t is the number of spanning trees generated. On the other hand, there is enough evidence to conclude that for sparse graphs, Char's original implementation is superior to MOD-CHAR. >

A distributed algorithm for minimum weight spanning trees based on echo algorithms

Abstract: A distributed algorithm based on echo algorithms is presented which constructs the minimum-weight spanning tree in a general undirected graph In the worst case, the algorithm needs at most (2m+2(n-1) log (n/2)) messages and (2d log n) time, where d is the diameter of the network In the best case, it needs only 2m messages and 2d time The algorithm works in phases, and each phase consists of a down wave and an up wave When the number of fragments is cut by at least one half in each phase, it needs at most O(log n) phases On average, the algorithm needs only (m) messages and O(d) time The algorithm itself is simple, so that other distributed algorithms based on it can be derived more easily >

Minimal spanning trees: an empirical investigation of parallel algorithms

Abstract: The objective of this investigation is to empirically test parallel algorithms for finding minimal spanning trees. Computational tests were conducted on three serial versions of Prim's algorithm, a serial version of Prim's algorithm, and a serial version of Sollin's algorithm. For complete graphs, our implementation of the Prim algorithm is best. As the graph density is reduced, our implementation of Kruskal's algorithm is superior, and for very sparse graphs, the Sollin algorithm dominates. Parallel implementations of both the Prim algorithm and the Sollin algorithm were empirically tested on a Sequent Symmetry S81 multicomputer. In tests involving ten processors, the speedups ranged from a low of 2.79 to a high of 6.81.

Constructing the optimal rectilinear Steiner tree derivable from a minimum spanning tree

Abstract: A polynomial time algorithm is given for constructing the minimum cost rectilinear Steiner tree (RST) that is derivable from a minimum spanning tree (MST) of a given point set, such that the MST edges have staircase layouts in the RST. RSTs produced by the algorithm have a property called stability, which enables the rerouting of any subset of the RST edges, while maintaining the cost of the RST, and not causing overlaps with each other or with the other RST edges. >

An algorithm for geometric minimum spanning trees requiring nearly linear expected time

Abstract: We describe an algorithm for finding a minimum spanning tree of the weighted complete graph induced by a set ofn points in Euclideand-space. The algorithm requires nearly linear expected time for points that are independently uniformly distributed in the unitd-cube. The first step of the algorithm is the spiral search procedure described by Bentleyet al. [BWY82] for finding a supergraph of the MST that hasO(n) edges. (The constant factor in the bound depends ond.) The next step is that of sorting the edges of the supergraph by weight using a radix distribution, or “bucket,” sort. These steps require linear expected time. Finally, Kruskal's algorithm is used with the sorted edges, requiringO(nα(cn, n)) time in the worst case, withc>6. Since the function α(cn, n) grows very slowly, this step requires linear time for all practical purposes. This result improves the previous bestO(n log log*n), and employs a much simpler algorithm. Also, this result demonstrates the robustness of bucket sorting, which requiresO(n) expected time in this case despite the probability dependency between the edge weights.

Topological analysis of multibody systems for recursive dynamics formulations

Abstract: Graph theory is used to characterize the topology of multibody systems for high speed parallel computer dynamic simulation. Decoupled loops are defined for use in the recursive dynamics formulations, wherein Langrange multipliers can be eliminated concurrently within each decoupled loop. A row-scanning process for the nondirected adjacency matrix of a graph is described, to generate an identification array that facilitates compact storage and defines system connectivities. A decision tree search algorithm is employed to generate all spanning trees associated with a closed loop graph. For each spanning tree generated from the decision tree search algorithm, a precedence array is defined. A path matrix for the spanning tree and an outdegree of junction nodes are defined to assist in parallel implementation of recursive dynamics algorithms and are then constructed from the precedence array. Finally, an optimal tree search algorithm that identifies a spanning tree that leads to best solution sequence...

MOD-CHAR: An Implementation of Char's Spanning Tree Enumeration Algorithm and Its Complexity Analysis

Abstract: Abstruct -An implementation, called MOD-CHAR, of Char’s spanning tree enumeration algorithm [3] is discussed. Two complexity analyses of MOD-CHAR are presented. It is shown that MOD-CHAR leads to better complexity results for Char’s algorithm than what could be obtained using the straightforward implementation implied in Char’s original presentation 131. The class of graphs for which MOD-CHAR and, hence, Char’s algorithm has linear time complexity per spanning tree generated is identified. This class is more general than the corresponding one identified in [7J. Using a result due to Matula [lo], [12] on random graphs, it is proved that for almost all graphs MOD-CHAR has linear worst-case time complexity per spanning tree generated. It is also shown that for any complete graph MOD-CHAR requires, on the average, at most seven computational steps to generate a spanning tree. This result and computational experiences provide evidence to believe that for dense graphs of any order the time complexity of MOD-CHAR is O( t), where t is the number of spanning trees generated. On the other hand, there is enough evidence to conclude that for sparse graphs, Char’s original implementation is superior to MOD-CHAR.