Topic
Prim's algorithm
About: Prim's algorithm is a research topic. Over the lifetime, 775 publications have been published within this topic receiving 17971 citations. The topic is also known as: DJP algorithm & Jarník algorithm.
Papers published on a yearly basis
Papers
More filters
12 May 2009
TL;DR: A linear-time algorithm for this problem on permutation graphs that improves a previous result that runs in O (n 3) time where n is the number of vertices in the input graph.
Abstract: The minimum vertex ranking spanning tree problem on graph G is to find a spanning tree T of G such that the minimum vertex ranking of T is minimum among all possible spanning trees of G . In this paper, we propose a linear-time algorithm for this problem on permutation graphs. It improves a previous result that runs in O (n 3) time where n is the number of vertices in the input graph.
TL;DR: In this paper , the authors considered the case of finding the lowest cost replacement edge for each edge of the minimum spanning tree (MST), which is a tree that connects all of the vertices of the graph with minimum sum of edge weights.
Abstract: Given an undirected, weighted graph, the minimum spanning tree (MST) is a tree that connects all of the vertices of the graph with minimum sum of edge weights. In real world applications, network designers often seek to quickly find a replacement edge for each edge in the MST. For example, when a traffic accident closes a road in a transportation network, or a line goes down in a communication network, the replacement edge may reconnect the MST at lowest cost. In the paper, we consider the case of finding the lowest cost replacement edge for each edge of the MST. A previous algorithm by Tarjan takes $O(m \alpha(m, n))$ time, where $\alpha(m, n)$ is the inverse Ackermann's function. Given the MST and sorted non-tree edges, our algorithm is the first that runs in $O(m+n)$ time and $O(m+n)$ space to find all replacement edges. Moreover, it is easy to implement and our experimental study demonstrates fast performance on several types of graphs. Additionally, since the most vital edge is the tree edge whose removal causes the highest cost, our algorithm finds it in linear time.
01 Mar 1992
TL;DR: An efficient parallel algorithm for constructing a breadth-first spanning tree of an interval graph based on elegantly capturing the structure of a given collection of intervals is designed, which is found to be instrumental in solving many other problems including the computation of a depth-depth spanning tree.
Abstract: The authors design an efficient parallel algorithm for constructing a breadth-first spanning tree of an interval graph. Their novel approach is based on elegantly capturing the structure of a given collection of intervals. This structure reveals important properties of the corresponding interval graph, and is found to be instrumental in solving many other problems including the computation of a breadth-depth spanning tree, which they report for the first time. The algorithm requires O(logn) time employing O(n) processors on the EREW PRAM model. >
26 Mar 2007
TL;DR: This paper eliminates the daemon from the self-stabilizing leader election algorithm of Xu and Srimani by making random choices to avoid interference between neighbor nodes, and shows that the average execution time for this algorithm is much lower than O(N4).
Abstract: This paper deals with the self-stabilizing leader election algorithm of Xu and Srimani that finds a leader in a tree graph. The worst case execution time for this algorithm is O(N4), where N is the number of nodes in the tree. We show that the average execution time for this algorithm, assuming two different scenarios, is much lower than O(N4). In the first scenario, the algorithm assumes a equiprobable daemon and it only privileges a single node at a time. The average execution time for this case is O(N2). For the second case, the algorithm can privilege multiple nodes at a time. We eliminate the daemon from this algorithm by making random choices to avoid interference between neighbor nodes. The execution time for this case is O(N). We also show that for specific tree graphs, these results reduce even more.