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

A minimum spanning tree algorithm with inverse-Ackermann type complexity

Abstract: A deterministic algorithm for computing a minimum spanning tree of a connected graph is presented. Its running time is 0(m a(m, n)), where a is the classical functional inverse of Ackermann's function and n (respectively, m) is the number of vertices (respectively, edges). The algorithm is comparison-based : it uses pointers, not arrays, and it makes no numeric assumptions on the edge costs.

Minimum cuts in near-linear time

Abstract: We significantly improve known time bounds for solving the minimum cut problem on undirected graphs. We use a "semiduality" between minimum cuts and maximum spanning tree packings combined with our previously developed random sampling techniques. We give a randomized (Monte Carlo) algorithm that finds a minimum cut in an m-edge, n-vertex graph with high probability in O(m log3n) time. We also give a simpler randomized algorithm that finds all minimum cuts with high probability in O(m log3n) time. This variant has an optimal RNC parallelization. Both variants improve on the previous best time bound of O(n2 log3n). Other applications of the tree-packing approach are new, nearly tight bounds on the number of near-minimum cuts a graph may have and a new data structure for representing them in a space-efficient manner.

An efficient evolutionary algorithm for the degree-constrained minimum spanning tree problem

Abstract: The representation of candidate solutions and the variation operators are fundamental design choices in an evolutionary algorithm (EA). This paper proposes a novel representation technique and suitable variation operators for the degree-constrained minimum spanning tree problem. For a weighted, undirected graph G(V, E), this problem seeks to identify the shortest spanning tree whose node degrees do not exceed an upper bound d/spl ges/2. Within the EA, a candidate spanning tree is simply represented by its set of edges. Special initialization, crossover, and mutation operators are used to generate new, always feasible candidate solutions. In contrast to previous spanning tree representations, the proposed approach provides substantially higher locality and is nevertheless computationally efficient; an offspring is always created in O(|V|) time. In addition, it is shown how problem-dependent heuristics can be effectively incorporated into the initialization, crossover, and mutation operators without increasing the time-complexity. Empirical results are presented for hard problem instances with up to 500 vertices. Usually, the new approach identifies solutions superior to those of several other optimization methods within few seconds. The basic ideas of this EA are also applicable to other network optimization tasks.

A weighted coding in a genetic algorithm for the degree-constrained minimum spanning tree problem

Abstract: The coding by which chromosomes represent candidate solutions is a fundamental design choice in a genetic algorithm. This paper describes a novel coding of spanning trees in a genetic algorithm for the degree-constrained minimum spanning tree problem. For a connected, weighted graph, this problem seeks to identify the shortest spanning tree whose degree does not exceed an upper bound k ≥ 2. In the coding, chromosomes are strings of numerical weights associated with the target graph’s vertices. The weights temporarily bias the graph’s edge costs, and an extension of Prim’s algorithm, applied to the biased costs, identifies the feasible spanning tree a chromosome represents. This decoding algorithm enforces the degree constraint, so that all chromosomes represent valid solutions and there is no need to discard, repair, or penalize invalid chromosomes. On a set of hard graphs whose unconstrained minimum spanning trees are of high degree, a genetic algorithm that uses this coding identifies degree-constrained minimum spanning trees that are on average shorter than those found by several competing algorithms.

Flexible search engine having sorted binary search tree for perfect match

Abstract: A binary search tree is structured so that keys or addresses associated with data in the bottom vertices are arranged in a predetermined order, such as ascending key address order. The root vertex and each hierarchy vertex contains the lowest value key from each child vertex and are thus similarly arranged by key value order. Each vertex of each level contains at least k and no more than 2k−1 keys, where k is an integer ≦2 and is constant for all vertices of a given level, but may vary between levels. The result is a structured tree having equal path lengths between the root vertex and each bottom vertex for search purposes. Keys are deleted and inserted to the bottom vertices by restructuring the tree under control of computer instructions.

Computing a Diameter-Constrained Minimum Spanning Tree in Parallel

Abstract: A minimum spanning tree (MST) with a small diameter is required in numerous practical situations. It is needed, for example, in distributed mutual exclusion algorithms in order to minimize the number of messages communicated among processors per critical section. The Diameter-Constrained MST (DCMST) problem can be stated as follows: given an undirected, edge-weighted graph G with n nodes and a positive integer k, find a spanning tree with the smallest weight among all spanning trees of G which contain no path with more than k edges. This problem is known to be NPcomplete, for all values of k; 4 ≤ k ≤ (n - 2). Therefore, one has to depend on heuristics and live with approximate solutions. In this paper, we explore two heuristics for the DCMST problem: First, we present a one-time-treeconstruction algorithm that constructs a DCMST in a modified greedy fashion, employing a heuristic for selecting edges to be added to the tree at each stage of the tree construction. This algorithm is fast and easily parallelizable. It is particularly suited when the specified values for k are small--independent of n. The second algorithm starts with an unconstrained MST and iteratively refines it by replacing edges, one by one, in long paths until there is no path left with more than k edges. This heuristic was found to be better suited for larger values of k. We discuss convergence, relative merits, and parallel implementation of these heuristics on the MasPar MP-1 -- a massively parallel SIMD machine with 8192 processors. Our extensive empirical study shows that the two heuristics produce good solutions for a wide variety of inputs.

A new genetic algorithm for the optimal communication spanning tree problem

Abstract: This paper proposes a new genetic algorithm to solve the Optimal Communication Spanning Tree problem. The proposed algorithm works on a tree chromosome without intermediate encoding and decoding, and uses crossovers and mutations which manipulate directly trees, while a traditional genetic algorithm generally works on linear chromosomes. Usually, an initial population is constructed by the standard uniform sampling procedure. But, our algorithm employs a simple heuristic based on Prim's algorithm to randomly generate an initial population. Experimental results on known data sets show that our genetic algorithm is simple and efficient to get an optimal or near-optimal solution to the OCST problem.

An online genetic algorithm for dynamic Steiner tree problem

Abstract: Dynamic Steiner tree problem (DST) is described as the multipoint routing problem in the communication networks, in which a set of nodes and the set of Steiner vertices in the connection is changing with time. The problem is based on the Steiner tree problem on graphs. In the DST problem, the Steiner minimal tree cost is changing with time because the requests of the Steiner vertices or weights of graph edge are changing with time. We propose an online genetic algorithm (OLGA) to solve this problem. OLGA is different from general GA in that it does not evaluate individual against a fixed object, since the object changes with time. An individual in GA is expressed by the gene of the graph nodes. As an adapt method, the Prim algorithm is used to calculate the value of the cost of the graph nodes. In order to make our algorithm robust, we applied the B-problem set from Beasley (1990), thus the problems are based on the B-problem set. From experimental simulations, we show that the OLGA is robust to calculate this kind of problems.

Recognizing unordered depth-first search trees of an undirected graph in parallel

Abstract: Let G be an undirected graph and T be a spanning tree of G. In this paper, an efficient parallel algorithm is proposed for determining whether T is an unordered depth-first search tree of G. The proposed algorithm runs in O(m/p+log m) time using p processors on the EREW PRAM, where m is the number of edges contained in G. It is cost-optimal and achieves linear speedup.

A Practical Algorithm for the Minimum Rectilinear Steiner Tree

Abstract: An O(n^2) time approximation algorithm for the minimum rectilinear Steiner tree is proposedThe approximation ratio of the algorithm is strictly less than 15The computing performances show the costs of the spanning trees produced by the algorithm are only 08% away from the optimal ones

Comparison of the Prim-Dijkstra and kraskal algorithms on an associative parallel processor

Abstract: With the help of a model of an associative parallel processor with vertical processing (STAR computer), Prim-Dijkstra and Kraskal algorithms for finding a minimal spanning tree of an undirected graph represented in the form of a list of edges and their weights are compared. A relatively simple representation of the Prim-Dijkstra algorithm is constructed in which the initial node is taken into account. The Kraskal algorithm is also presented and the possibility of eliminating the stage of preliminary sorting of edges by their weights is shown.

A practical algorithm for the minimum rectilinear steiner tree

Abstract: AnO(n 2) time approximation algorithm for the minimum rectilinear Steiner tree is proposed. The approximation ratio of the algorithm is strictly less than 1.5. The computing performances show the costs of the spanning trees produced by the algorithm are only 0.8% away from the optimal ones.