A NEW PARALLEL ALGORITHM FOR COMPUTING MINIMUM SPANNING TREE

International Journal of Soft Computing, Mathematics and Control (IJSCMC),Vol.2,No.2,May 2013
1
A NEW PARALLEL ALGORITHM FOR
COMPUTING MINIMUM SPANNING TREE
M. I. Moussa1
1
Computer Science Department, Faculty of Computer Science and Informatics, Benha
University, Benha, Egypt.
moussa_6060@yahoo.com
E. M. Badr2
2
Scientific Computing Department, Faculty of Computer Science and Informatics, Benha
University, Benha, Egypt.
badrgraph@gmail.com
ABSTRACT
Computing the minimum spanning tree of the graph is one of the fundamental computational problems. In
this paper, we present a new parallel algorithm for computing the minimum spanning tree of an undirected
weighted graph with n vertices and m edges. This algorithm uses the cluster techniques to reduce the
number of processors by fraction 1/ ( )f n and the parallel work by the fraction O (1 log( ( ))f n ),where ( )f n is an
arbitrary function. In the case ( ) 1f n = , the algorithm runs in logarithmic-time and use super linear work on
EREWPRAM model. In general, the proposed algorithm is the simplest one.
KEYWORDS
Minimum spanning tree, Parallel algorithm, Cluster techniques
1.INTRODUCTION
The problem of determining a minimum spanning tree in parallel is the one major issue which has
been the focus of much research. Here is a brief summary of related results. In 1979 D. H.
Chandra, and D. V. Sarwate [1] presented a parallel deterministic algorithm for graphs with n
vertices and m edges, that runs in O ( 2
lo g n ) time using n l o g n
2 processors on the CREW model.
In 1982, F. Chin, J. Lam, and I. Chen [3] gave a parallel deterministic algorithm, that runs in O
( 2
log n ) time using 2 2
n log n processors Thus their algorithm achieves linear speed-up when the
input graph is a complete graph. However, it is not very work-efficient for spare graphs. In 1982
Y. Shiloach and U. Vishkin [4] improved the result to O( logn ) time and O( m n+ ) processors on
the CRCW model R. Cole and U. Vishkin [7] presented the best deterministic CRCW parallel
MST and connectivity algorithms that require O( log n ) time and O((m + n)a(m, n)/ log n)
processors. Recently in 1999 K. W. Chong, Yijie Han, and Tak W. Lam [12] presented a new
approach for finding the minimum spanning trees that runs in O( logn ) time using
m n+ processors on EREW PRAM.

2
Thus their algorithm as R. Cole and U. Vishkin algorithm all use super-linear work. There are
somewhat simpler logarithmic time linear expected work randomized minimum spanning tree
algorithms, which have been successfully analyzed by R. Cole, P. N. Klein and R. E. Tarjan [10].
They improved the running time
*
log n
O (2 log n) of their previous work [8] to O ( logn ).
Their algorithms based on the sequential randomized linear-time algorithm to find MST which
has been discovered by P. N. Klein, D. R. Karger and R. E. Tarjan [9]. In 2005 David A. Bader
and Guojing Cong [2] gave a new practical parallel minimum spanning tree algorithm with
implementation on SMPs. In 2005 Moussa [14] presented another algorithm for finding the
minimum spanning trees that runs in O ( logn ) time using m + n processors on EREW PRAM. In
this paper we improve our result [14] by presenting a practical parallel algorithm on EREW
PRAM model for computing MST by reducing the number of used processors. This algorithm can
be has a practical application, where it can use a limited number of processors which does not
depend on the number of vertices in the graph. At the same time, our algorithm is considered the
best one among all the parallel deterministic algorithms presented in this area because it is
simpler and it resumes lower parallel cost.
The remainder of this paper is organized as follows. In section 2 we choose the parallel model of
computation. Section 3 gives some assumptions and definitions related with the minimum
spanning trees. In section 4, we present and discuss the parallel algorithm for solving MST
problem. Section 5 discusses the parallel running time and the number of used processors. Section
6 is the conclusion of this research.
2. THE MODEL
We let an EREW PRAM model employs O(n f(n))processors where n is the number of vertices
and m is the number of edges in the given graph ,G each processor able to perform the usual
computation of a sequential machine using some fixed amount of local memory. The processors
communicate through a shared global memory to which all are connected. The processor can
access data computed by another processor and stored in the shared memory in constant time.
3. ASSUMPTIONS AND DEFINITIONS
Given a graph G with n vertices and m edges, we assume that the input graph G is given in the
form of adjacency lists, where every vertex v has a linked list ( )L v of incident edges ( , )v w . For
instance, if e = ( , )u v is an edge in G , then e appears in the adjacency list of u and v . We call
each copy of e as the mate of the other. In order to differentiate between them we use the
notations ( , )u v and ( , )v u to indicate that the edge originates from u and v respectively. The
weight of e , which can be any integer value, is denoted ( )w e . The proposed algorithm can be
implemented for a graph in which the weights of all edges are distinct, or there are some different
edges that have the same weights. We therefore say that the input graph G may have a unique
minimum spanning tree, or more than one minimum spanning tree. The minimum spanning tree
will be referred to as GT throughout this paper. We also assume that G is an undirected
connected graph and consists of only one component. Let 1 2{ , , . . . , }tF T T T= be an arbitrary set
of sub-trees of G . If a tree iT contains no edge incidents on a vertex v , then v forms a tree.
Consider any edge ( , )e u v G= ∈ and tree .iT F∈ . If both vertex u and vertex v belong to iT
then e is called an internal edge of iT ; if only one vertex of { ,u v } belongs to iT , then e is called

3
an external edge. F is said to be a k −forest if each tree iT F∈ has at least k vertices. The tree
j iT T≠ is adjacent to iT if there is an edge e = ( , )u v , ,i ju T v T∈ ∈ . If jT is adjacent to iT , then
the best edge from iT to jT is the minimum cost e = ( , )u v , , .i ju T v T∈ ∈
For every tree iT F∈ the linked list of iT is the set of all best edges from iT to its adjacent trees
jT , and is written by ( ).iL T For each tree iT , if e is the minimum weight external edge
connecting a vertex in iT to a vertex in jT , then, the edge e belongs to GT . If e = ( , )u v is an
external edge from iT to jT that is not a minimal weight external edge, then e is never an edge
in GT .
4. THE PARALLEL MST ALGORITHM
At the beginning of the algorithm, we are using the function ( ) 2 logf n m=    ; the
function ( )f n does not depend on the number of trees in each pass of the algorithm. The study
classifies the vertex set into a bounded number O( n f(n) ) of subsets 1 n f(n)V(C ),...,V(C ) such that
the nodes of each subset are chose randomly. We can consider this as a simple and non-time-
consuming clustering of the graph G such that, there is no class contains another different class
completely, in the same time may be there were some common elements between two or more
classes. In addition, we can choose any fast graph clustering algorithm as a preprocessing step for
our parallel minimum spanning tree algorithms. Let 1 ( )( ),..., ( )n f nV C V C are the names of the
resulting classes from the clustering of the given graph. The algorithm has O(log n/loglog n)passes
and it runs in a way similar to the sequential algorithm of M. Fredman and R. Tarjan [6]. In each
pass, the algorithm reduces the number of trees t by the fraction1 ( )f n . In other words,
consider the pass that begins with t trees and 0m edges the number of trees 0t remaining after
the pass satisfies 0 02 ( )t m f n≤ . In the beginning each pass assigns all single trees white. Each
pass creates an empty Fib-Heap for each single tree and inserts its linked list (the set of all best
edges from T to its adjacent trees) as items in the heap with keys equal to the weight ( )w e of
the edge. It then chooses the edge with the minimum weight and begins from the other end point
of that edge.
The pass grows a single white tree only until its heap of incident edges exceeds a certain critical
size and assigned it white. The algorithm continues in this way until there is no white tree
remaining and then condenses every tree into a single super-vertex. The algorithm performs the
condensing implicitly and then begins a new pass of the same kind over the condensed graph.
After a sufficient number of passes, only one super-vertex will remain. By expanding the super-
vertex back into trees then a minimum spanning tree is remaining. The algorithm maintains a
forest defined by the edges so far selected to be in the minimum spanning tree. It initializes the
forest T such that it contains each of the n vertices of G as a one-vertex tree and maintains a key
for measuring ( )w e , which represents the tentative cost of incident edge e to T .
1. Form one trivial tree per each vertex v .
2. for each tree v V∈ do
Set ( )key v =∞, and color each vertex v white.
3. end for

4
Algorithm 1: Procedure Initialization
The processor assignment for initialization procedure is to provide one processor to each class. A
processor colors the vertex white and sets the key of the vertex to ∞, and then this procedure takes
O(log )n time and O ( ( ))n f n processors. The main procedure of the MST algorithm is described as
follows:
1. For ( )l o g n / l o g l o g ntimes do
2. Call Get-New-Tree ( T ) procedure.
3. end for
Algorithm 2: MST Main procedure
In the first pass of the algorithm the input old tree will be considered as a single vertex. For each
class iC we assign one processor iP and create the Fib-Heap iH . For each vertex i iv C∈ insert
the set of all edges incident with iv in the heap with a key equal the weight of every edge. Since it
is not expected that all vertex degrees will equal one, then we repeat the following step for at
most ( )f n times: Find a minimum cost edge with exactly one endpoint in the selected set of
vertices (sub-trees) and add it to the forest GT ; add its other endpoint to the selected set of
vertices. After the above process, we get the first set F of nontrivial sub-trees of G with two non-
empty sets of edges. The first of those are the internal edges (contain at least one edge); the
second includes the external edges, which will be at most equal to  , where  refers to the
number of end vertices in the non-trivial tree; it will be determined later. The end vertices may be
incident to external or internal edges. The forests 11 2{ , ,..., }tF T T T= of sub-trees of G are called
the old trees. These old trees will be the input to the next pass of the algorithm in order to grow
them to get other new trees which will be the old ones for the following pass. The following is a
description of a single pass (pass i ) of the algorithm. The pass begins with a forest of previously
grown trees (the old trees) defined by the edges so far added to the forest. The pass connects these
old trees into new larger trees. Start with the old trees by numbering it consecutively from one
and assign to each vertex the number of the tree containing it. Each processor should keep its
initial vertices. This allows us to refer to the trees by the numbers and directly access the old tree
( )T v that contains the vertex v .
Next clean up the linked list of each old tree by removing every edge that connects any two
vertices in the same old tree and all but a minimum-cost edge connecting each pair of old trees. A
full description of the cleaning process using lexicographical sorting is given after Algorithm-3.
After cleaning up construct a new edge list for each old tree. However since every old tree and all
vertex incidents with its internal edges have the same number and are sorted lexicographically
according to their end point then we can in constant time merge the linked list of all vertices
which are contained in the current grown tree. The linked lists of the old trees are merged into a
single list; the time does not depend on the length of the list. We use a technique introduced by
Tarjan and Vishkin [5] and Chong, Han and Lam [13]. The algorithm guarantees that the merging
process will not fail because all the edges of iT (or its mate) are included in the corresponding
linked list. In order to finish the growth process empty the heap and set the keys of all old trees
with key equals to infinity.
1. Number the old trees consecutively starting from one and assign to each vertex the number
of the tree that contains it.
2. Prune the linked list of each old tree.
3. For each old tree construct a list of edges that have one endpoint in T .

5
4. Every processor Pi calls the Grow-Step ( T ) procedure.
5. Finish the growth step by emptying the heap and set ( )k e y T = ∞ .
Algorithm 3: Get-New-Tree (T )
(Step 2) Prune the linked list: Discard every edge that connects two vertices in the same old tree
as follows. When the subroutine prune (step 2 in Algorithm 3) considers an edge with the same
number for its both two endpoints, it assigns this edge an internal (dead). Afterward sort the edges
(external edges) that connect different old trees lexicographically according to their endpoints.
Sorting can be performed in parallel by using the Parallel Radix Sort algorithm as described
earlier. The algorithm sorts n elements in ( )logO n time using ( )n f n EREW PRAM processors.
In the sorted list, all multiple edges should end up in a sequence. Then, we save for each sequence
of multiple ( ),x y edges the minimum weight while the remaining multiple ones are deleted.
(Step 4) Grow Step: In the Grow-Step procedure we maintain the set A of the vertices of the
current tree T that contains an old tree iT to be treated by processor iP . The implementation
assumes that graph G is represented by adjacency lists while the set of light edges ( )Te , which
are the edges that appear in the minimum spanning tree, is added consecutively to the forest .F
1. Create an empty Fib-Heap H .
2. Insert each ’T s edge into Hwith ( ) ( )key e w e= .
3. Let A T=
4. while ( )H f n< or the other end point of the edge belong to different class do
5. Repeat
6. Delete min-weight edge ( ),u v from the heap H
7. until T′ is not an element in A
8. A A { T }′← ∪
9. Add ( ),e u v= to the forest .F
10. if T′ is white then
11. Empty the heap
12. Set key of the current tree equal to infinity.
13. else
14. Insert each ( T′)’s edges into the heap H with ( ) ( )key e w e= .
15. end if
16. end while
17. Mark the current tree in white.
Algorithm 4: Grow-Step ( T )
Lemma 1. The number of end vertices  in a tree T with 1 2{ , ,. . . , }T nV v v v= equals
d e g ( ) 2
2 ( d e g ( ) 2 )
v
v
≥
+ −∑
Proof:
Suppose 1 2{ , ,. . . , }v v v be the vertices which have degree equal one. While
21{ , ,. . . , }nv v v + + have degree more than one,
1 nz z+1deg(v ) +...+deg(v ) +deg(v ) +...+deg(v ) = 2n - 2 .

6
( )( )
d e g ( ) 2
d e g v 2= = 2 n 2 2 n 2
v

≥
− − − ++ ∑
deg( ) 3
deg( ) 2.2
v
v
≥
−= + ∑
Note, that it is possible to internal edges to have incidents with some end vertices of T .
Consequently the number of all external edges is at most equal to  . This can be explained by
the next lemma.
Lemma 2. The number of the external edges in a non-trivial tree T is  < ( )2 2 /r k r−
Proof:
Suppose that tree T has the vertex set TV and the edge set TE and that the cardinality of its
vertices is denoted Tn while the cardinality of its edge set is denoted Tm . If T0 is the first old
tree among those making up T and it is placed in the heap then 0T will keep growing until the
heap reaches size ( )f n . At that time the current tree T ′ that contains 0T will have more
than ( )f n incident edges. Other trees may later become connected to T ′ causing some of these
incident edges to have their endpoints in the final tree T . According to that, after the completion
of the pass each tree T will have more than ( )f n edges with at least one endpoint in T . This
implies that
( )
d e g ( ) 2 ( )
v V T
v f n
∈
≥∑
If the degree of each vertex in T has an upper bound r then
Trn > 2f(n) (1)
( ) ( )2 ( - ) 2
( 2)
T T
T
r n r n
r n
 

− ≤ −
−
<
<
. (2)
2 ( )Tr n f n>
From the two inequalities (1) and (2) and by dividing them, we find the relation between the size
of the edge list for Tand ( )f n is ( )/2 ( ) 2 /f n r r ≤ − . Then the number of external edges for each
tree Tis less than ( )z =O f(n) .
5. THE WORK AND THE RUNNING TIME FOR A PASS
The running time of step-1 depends on the number of vertices in each class; this number is at
most O( logn ) vertex. So this step can be implemented to run in O( logn )time using
/ ( )n f n processors. The running time of step-2 depends on the number of the external edges,
which is greater than the size of the linked list of the tree.
So the external edges has been sorted in a lexicographic order (the linked list of the tree) in
parallel by using the Parallel Radix Sort algorithm as was described in problem 4.16 page 189
[11]. Since the number of the external edges in a non-trivial tree T is ( )O ( )f n = according
to Lemma (2). The algorithm was used here to sort at most / ( )n f n times  edges in O ( logn )

7
time using / ( )n f n EREW PRAM processors. Step-3 has been implemented to run in
( )O lo g n time using / ( )n f n processors. To analyze the running time of Step-4, we need to
determine the upper bound of the size of the edge list for each tree T after the pass. Lemma (2) is
the key to the complexity analysis. It gives the upper bound of the adjacency list (and the linked
list) of each tree T so as to minimize the running time of pruning the adjacency list of T . At the
same time, the lemma guarantees that every pass creates a new big tree by replacing the old trees
1{ , ,. . . , }i i jT T T+ by their union where i j< is the smallest index such that the size of the
associated heap H is less than or equal to critical size ( )f n .
The result of the above lemma implies that every pass grows a single tree T by absorbing the old
trees one by one, so we can determine the running time required to grow a new tree. It needs at
most r delete-minimum operations, each on a heap of size ( )f n or smaller. Then the total time
Step-4 procedure is O( log ( )r f n ) time, using at most / ( )n f n EREW PRAM processors.
Depending on the maximum number of vertices in each class, Step-5 takes O ( logn ) running
time lass using / ( )n f n processors. The running time per pass is O ( logn )running time
using / ( ) logn f n n n= processors.
Lemma 3 The algorithm terminates after no more than O ( log loglogm m ) passes.
Proof :
Since each of the m edges has only two endpoints in the given graph G then the number of trees
remaining after the first pass is at most 2 / ( )m f n . For a pass i , which begins with t trees
and m < m′ edges (some edges may have been discarded), after i passes the number of remaining
trees is at most 2 /( ( ))i i
m f n , where ( ) 2 lo gf n m=   . Since the expected number of trees that
are equal to one only occurs in the last pass then the number of passes is at most
O( log loglogm m )□
6.SUMMARIES
This paper presented a new deterministic parallel algorithm on EREW PRAM. The study used the
function ( )f n to control the number of processors. In the case ( ) 1f n = ; the proposed parallel
algorithm has the same running time and the same number of processor as the previous best
deterministic parallel minimum spanning tree algorithms, but our parallel algorithm is the
simplest one. If the study used the functionf(n)=O(logn) the number of processors reduced by the
fraction1 log n , and compared with the previous results the work of our parallel algorithm reduced
by the fraction O (1 log log n ), and it is O ( log loglogn n n ) on EREWPRAM model.
REFERENCES
[1] D. H. Chandra and D. V. Sarwate. Computing connected components on parallel computers.
Communications of ACM, 22:461–464, 1979.
[2] David A.Bader and Guojing Cong” A fast, parallel spanning tree algorithm for symmetric
multiprocessors (SMPs)” Journal of Parallel and Distributed Computing Volume 65, Issue 9 Pages:
994 - 1006
[3] J.Lam, F. Chin, and I. Chen “Efficient parallel algorithms for some graph problems” Communications
of the ACM, 25(9):659–665, 1982.

8
[4] Y. Shloach and U. Vishkin. An o(log n) parallel connectivity algorithm. J. of Algorithms, 3:57–67,
1982.
[5] R. E. Tarjan and Uzi Vishkin. An efficient parallel biconnectivity algorithm. SIAM Journalof
COMPUT,14(4):863–874, 1985.
[6] R. E. Tarjan and M. L.Fredman. Fibonacci heaps and their uses in improved network optimization
algorithms. Journal of the ACM, 34(3):596–615, July 1987.
[7] R. Cole and U. Vishkin. Approximate parallel scheduling: Applications to logarithmic-time optimal
parallel graph algorithms. Information and computation, 92(1):1–47, 1991.
[8] R. Cole, R. E. Tarjan, and P. N. Klein. A linear-work parallel algorithm for finding minimum
spanning trees. 6th Annual ACM Symposium on Parallel Algorithms and Architectures, pages 11–15,
1994.
[9] D. R. Karger, R. Tarjan, and P. Klein. A randomized linear-time algorithm to find minimum
spanning trees. Journal of the ACM, 42:321–328, 1995.
[10] R. Cole, R. E. Tarjan, and P. N. Klein. Finding minimum spanning forests in logarithmic time and
linear work using random sampling. In Proc. SPAA ’96’, pages 243–250, 1996.
[11] S. G. Akl. Parallel Computation: Models and methods, pages 7, 189. Alan Apt, 1997.
[12] K. W. Chong, T. W. Lam, and Y. Han. On the parallel time complexity of undirected connectivity and
minimum spanning trees. SODA: ACMSIAM Symposium on Discrete Algorithms (A Conference on
Theoretical and Experimental Analysis of Discrete Algorithms), pages 243–250, 1999.
[13] K. W. Chong, T. W. Lam, and Y. Han. Concurrent threads and optimal parallel minimum spanning
trees algorithm. Journal of the ACM, 48(2):297–323, March 2001.
[14] M. Moussa. Parallel algorithms for the construction of special subgraphs. Ph.D Fak. f. Informatik,
Karlsruhe University,2006
Authors
1
Mahmoud Moussa received the B.Sc. (Mathematics) the M.(Pure Mathematics)
degree from Benha University, Benha, Egypt in 1993, 1999 respectively. Also, he
received Ph.D. (Computer Science) degree from Faculty of Information, UNIVERSITY
OF KARLSRUHE, KARLSRUHE CITY, GERMANY, in 2005. He is a University
assistant Prof. of Computer Science with the Benha University, Faculty of Computer and
Informatics, Department of Computer Science. His current research is Parallel
Programming, linear programming and Graph Theory.
2
El-Sayed Badr received the B.Sc. (Mathematics) the M.Sc. (Pure Mathematics)
degree from Benha University, Benha, Egypt in 1994, 2000 respectively. Also, he
received Ph.D. (Computer Science) degree from Department of Applied Informatics,
Macedonia University, Thessaloniki, Greece, in 2006. He is a University lecturer of
Computer Science with the Benha University, Faculty of Computer and Informatics,
Department of Scientific Computing. His current research is Parallel Programming,
linear programming and Graph Theory.

A NEW PARALLEL ALGORITHM FOR COMPUTING MINIMUM SPANNING TREE

Recommended

More Related Content

What's hot (20)

Similar to A NEW PARALLEL ALGORITHM FOR COMPUTING MINIMUM SPANNING TREE (20)

Recently uploaded (20)

A NEW PARALLEL ALGORITHM FOR COMPUTING MINIMUM SPANNING TREE