Li%!

i4
ELSEVIER

__ _EB

PARALLEL COMPUTING
Parallel Computing 22 (1996) 369-382

Minimum-weight degree-constrained spanning tree problem: Heuristics and implementation on an SIMD parallel machine a2
Bruce Boldon, Narsingh Deo, Nishit Kumar
*
Department of Computer Saence, UniLjersityof Central Florida, Orlando, FL 32816-2362, USA

Received 20 February 1995; revtsed 20 August 199.5, 16 November 1995

Abstract
The minimum spanning tree problem with an added constraint that no node in the spanning tree has the degree more than a specified integer, d, is known as the minimumweight degree-constrained spanning tree (d-MST) problem. Such a constraint arises, for example, in VLSI routing trees, in backplane wiring, or in minimizing single-point failures for communication networks. The d-MST problem is NP-complete. Here, we develop four heuristics for approximate solutions to the problem and implement them on a massivelyparallel SIMD machine, MasPar MP-1. An extensive empirical study shows that for random graphs on up to 5000 nodes (about 12.5 million edges), the heuristics produce solutions close to the optimal in less than 10 seconds. The heuristics were also tested on a number of TSP benchmark problems to compute spanning trees with a degree bound d = 3.
Keywords:

Minimum spanning tree; Constrained

problems; NP-complete;

SIMD machines:

Heuristics

1. Introduction

Computing a minimum spanning tree (MST) is probably the best-known network optimization problem. In their comprehensive survey of historical development of the MST problem, Graham and Hell [15] trace the formulation and

* Corresponding author. Email: kumar@cs.ucf.edu Research partially supported by NSF grant CDA-9115281. A preliminary version of this paper was presented at Altec: Algonthms for Future Technologies. Prague, Czech Republic, March 8-11, 1995. 0167-8191/96/$15.00 0 1996 Elsevier Science B.V. All rights reserved SSDI 0167-8191(95)00010-5

370

B. Boldon et al. /Parallel Computing 22 (1996) 369-382

solution of the problem to Bortivka in 1926 and independently to Jarnick in 1930. Later, between 1956 and 1961, algorithms for the MST problem were proposed by Kruskal in 1956; Loberman and Weinberger in 1957 (which turns out to be similar to Kruskals); Prim in 1957 (which turns out to be similar to Jarnicks); Dijkstra in 1959 (which is similar to Prims); and Sollin in 1961 (similar to Bortivkas). The three distinct MST algorithms - Prims, Kruskals, and Sollins - have been implemented and studied extensively with various refinements and novel data structures for graphs of different orders and densities [l]. Some recent papers have examined theoretical versus practical behavior of MST algorithms [14,18,22-251. The MST algorithms have also been proposed for parallel machines in the past 20 years and more recently, implemented [7,10,17,201. In practice the MST must however satisfy some additional constraint, which often makes the problem NP-hard; for example, a bound on the degree, or a bound on the diameter of the tree. Thirteen such NP-complete variants were listed by Garey and Johnson [13]. Camerini, Galbiati, and Maffioli [3-51 catalogued eighteen spanning-tree parameters that one might wish to optimize. Computational complexity of finding a spanning tree that minimizes (or maximizes) a particular parameter was determined systematically for every variant. They also classified the doubly-constrained problems, in which bounds for two parameters must be satisfied simultaneously. Here, we study one such constrained MST problem - the minimum-weight degree-constrained spanning tree (d-MST) problem. Given an undirected, edgeweighted graph and an integer d, we are required to find a spanning tree with the minimum weight among all possible spanning trees that have no node with the degree exceeding d. Readers may note that the symbols d-MST will also be used to denote the spanning tree that satisfies the degree bound d, e.g. 3-MST for the spanning tree satisfying d = 3. The d-MST problem is obviously NP-complete since finding a minimum-weight Hamiltonian path (i.e. a traveling salesman tour without the last edge which brings the salesman to the starting node) is the same as the d-MST problem with d = 2. Moreover, the degree-constrained spanning tree (Problem ND1 in Garey and Johnson [13]) is a special case of the d-MST problem when all edge weights are the same. To the best of our knowledge, the d-MST problem was first posed and heuristically solved by Deo and Hakimi [9]. It arose in the context of backplane wiring among pins where no more than a fixed number of wire-ends could be wrapped around any pin on the wiring panel. Similarly, in communication networks since the maximum degree in a spanning tree is a measure of vulnerability to single-point failures, often the objective is to also minimize the vulnerability along with the spanning-tree weight [27]. In VLSI design, the limit on the number of transistors that can be driven by the output current of a transistor is the degree bound for VLSI routing trees. Ravi et al. [27] showed that approximating the d-MST problem to within a constant factor of the weight of an optimal tree is NP-hard. (Interestingly, for unweighted graphs a related NP-complete problem, of computing a spanning tree with the maximum degree being the smallest among all spanning trees, admits

B. Boldon et al. /Parallel Computing 22 (1996) 369-382

371

polynomial-time approximations within an additive constant of one from the optima1 degree, as shown by Fiirer and Raghavachari [12].) Ravi et al. developed a polynomial-time algorithm that approximates both the weight and the maximum degree of the spanning tree. For an n-node graph and a degree bound d, their algorithm computes a spanning tree with the maximum degree at most O(d log n) and the weight, within O(log n) times that of an optimal tree. Moreover, for weights obeying the triangle inequality they presented another approximation algorithm that finds a spanning tree satisfying the specified degree bound and with weight within (2 - Cd - 2)/(n - 1)) times the MST. The latter algorithm employs the short-cutting method proposed by Rosenkrantz et al. for the traveling salesman problem 1291. The d-MST problem has also been studied for Euclidean graphs. For d = 3, the problem was shown to be NP-hard by Papadimitriou and Vazirani [26], who conjectured that it is NP-hard for d = 4 as well. For points in a plane, Khuller et al. [19] recently proposed algorithms that find (i) 3-MSTs with a bound of 50% from the MST weight, and (ii> 4-MSTs with a bound of 25% from the MST weight. They also showed that for points in a plane there always exists a 5-MST with the same weight as the MST. Here, we develop four heuristics for the d-MST problem on arbitrary weighted graphs and carry out an extensive empirical study of their parallel implementations on a massively-parallel SIMD machine, MasPar MP-1. (We are not aware of any other empirical study of heuristics for the d-MST problem.) Our heuristics are described in Section 2 and their parallel implementations, in Section 3. The experimental results are presented in Section 4 and the conclusions, in Section 5.

2. The d-MST heuristics Throughout the paper, the input weighted-graph is assumed to be complete (as in [9,19,27]) and is specified by an IZX n weight matrix. Our d-MST heuristics consist of two phases: (i) MST computation (ii) Blacklisting. First, an MST of the given weight matrix is computed. Then, the Blacklisting phase increases the weights of those tree edges that are incident to nodes with the degree exceeding d. By increasing the weight, a tree edge is discouraged from appearing in the next spanning tree. It may be noted that penalizing a tree edge has the effect of moving that edge down in the sequence of all edges in the graph, sorted in increasing order of their weights. This sequence determines the edges that appear in an MST. The MST of the graph with new weights is computed next. Blacklisting followed by the MST computation is repeated alternately until a spanning tree is produced in which every node satisfies the degree bound. The approach described is similar to the dual simplex method, which starts with a superoptimal solution and moves towards the optimal striving to achieve feasibility. The dual simplex is useful for problems in which an optimal solution to the unconstrained (or under-constrained) problem is known (or can be computed easily), and we are required to solve the fully-constrained problem. For the d-MST

372

B. Boldon et al. /Parallel

Computing 22 (1996) 369-382

problem - since the unconstrained MST is easy to compute, we work from this initial (superoptimal) solution and move incrementally towards a feasible d-MST, sacrificing the weight-optimality as we progress. Also, the tabu search heuristic for combinatorial optimization has spirit similar to our blacklisting, However, whereas tabu search totally disallows search towards certain solutions in the combinatorial search space [11,21,30], our blacklisting simply guides the search towards certain solutions. The number of iterations and the quality of final solution hinge crucially on the blacklisting-function - a function that increases the weight of edges in the spanning tree. If the weights are increased by too large an amount the final solution may be far from optimal. On the other hand, increasing weights by too small an amount will result in an unacceptably slow convergence. Next, we develop four blacklisting functions underlying the four d-MST heuristics. 2.1. Blacklisting functions We denote the four blacklisting functions by BFl, BF2, BF3, and BF4. Each function alters the weight, w[e], of a tree edge, e, to a new weight, w[e]. Before describing the functions themselves we will first list the parameters used in their design, d: Given degree bound d[u]: Degree of node u in the spanning tree * Minimum and maximum edge-weights in the current spanning tree Wmin~ Wmaxe f[e]: Number of infeasible nodes that edge e is incident to. (A node u is called infeasible if d[v] > d.) It can take values 0, 1, or 2.
Blacklisting function BFl

Function BFl penalizes a tree edge, e, by an amount proportional to (i) the number, f[e], of infeasible nodes that edge e is incident to and (ii) the weight, w[e], as it relates to the range of edge-weights in the spanning tree. The equation used by BFl is
w(e) =w[e]

+f[e]

(;E;

I;;;)wm~x

For f [e] = 1, the possible values for the new weight, w[e], vary in the range wmin to 2w,,,; whereas, for f [e] = 2, in the range w,,, to 3w,,,. Also, note that an edge with the smallest weight (i.e. w[e] = w,& in the spanning tree does not get penalized even if it is incident to an infeasible node.
Blacklisting function BF2

Function BF2 is the same as BFl except for the following: In BFl, the weights of all tree edges incident to an infeasible node were increased. However, since a node in a spanning tree must have degree at least one, it is logical not to penalize the tree edge that has the smallest weight among all edges incident to that node. Weights of other tree edges are increased as in BFl.

B. Boldon et al. /Parallel Computing 22 (1996) 369-382

373

Blacklisting function BF3

Function BF3 penalizes an edge, e, such that the new weight, w[e], lies randomly in the range w[e] to wmax+ f[e](w,,, - w,,,,). The probability distribution of the random numbers in the range is a linear function with slope equal to a parameter that estimates, for an edge e = (u, LI), how seriously infeasible are the two end-nodes (u and cl) of e. This parameter, for an edge e, is computed by adding the numbers by which the degree of the end-nodes exceed d. Furthermore, the sum is normalized by dividing it with d. By biasing the random number generator in the manner described, the new weight, w[e], of an edge e is more likely to have a high value within the range if e is incident to nodes with large degree infeasibilities.
Blacklisting function BF4

Function BF4 is a modification of BF3, just as BFl is modified to obtain BF2. It probabilistically penalizes all tree edges incident to an infeasible node except the one with the smallest weight from among all edges incident to that node. 2.2. An example Consider the 3-MST problem on the 6-node complete, undirected graph specified by the (upper-diagonal elements of the) weight matrix shown in Fig. 1. For this graph the unconstrained MST with weight 36 has an infeasible node e with degree 4. Using the blacklisting function BF2, tree edges (a, e), Cc, e), and (d, e) with

Weight Matrix a a b c d I 9 12 18 13 15 17 6 10 7 8 20 21 5 1 19 22 1 b c d e

::-z
f d d e ia La
weight = 36

MST

3 -MST

weight = 39

weight = 37

weight = 38

Fig. 1 Blacklisting

function

BF2 for 3-MST.

374

B. Boldon et al. /Parallel Computmg 22 (I 996) 369-382

weights 8, 10, and 7 are penalized to get the new weights 14, 20, and 11, respectively. The edge (b, e) with weight 6 is not penalized since it has the smallest weight among the four tree edges incident to node e. Penalty imposed on a tree edge discourages that edge to appear in the next MST. However, whereas edges (a, e) and (c, e) are replaced in the next MST by edges (a, b) and (b, c), respectively; the edge (d, e) continues to appear despite the penalty on its weight. The MST of the updated weight-matrix is computed next and a spanning tree with weight 39 is obtained. The degree of node e reduces from 4 to 2. The heuristic terminates in only one iteration since the spanning tree obtained satisfies the degree bound 3. The 3-MST with weight 39 found by the heuristic is not optimal since there exists two other 3-MSTs with weights 37 and 38. The spanning tree with weight 37 is also the optimal 3-MST for the problem considered.

3. Parallel implementation Next, we describe the relevant details of our implementational environment and then in Section 3.2 show how they were exploited to implement our heuristics. A few machine-specific details are also included for interested readers who may wish to implement some other graph problems on the MasPar. A detailed listing of the parallel programs is available in our technical report [21. 3.1. Implementational environment MasPar MP-1 is a mesh-connected, SIMD machine. It has a front-end processor running on a Unix-like (Ultrix) operating system and a Data Parallel Unit (DPU) for executing parallel programs. The front-end machine is a micro-VAX workstation. The DPU consists of an Array Control Unit (ACU) and Processor Elements (PEs), organized as a two-dimensional array. Our machine has 8192 PEs organized in 128 columns and 64 rows. (These numbers may vary from installation to installation.) The ACU is a special-purpose processor for controlling the execution of the PEs. The program is stored in a special local memory bank of the ACU, from where it is broadcast to the PEs simultaneously. A PE consists of a 4-bit processor and a bank (64 Kbytes) of local memory. Each PE is connected to its 8 neighbors (wrapped around) in a connection scheme called xnet (i.e. a PE is connected directly to its East, West, North, South, North-East, North-West, South-East and South-West neighbors). The PEs are also connected through a global router. Local data in the PEs can be exchanged through the global router as well as the local xnet; however, the xnet configuration is faster but requires that all PEs get their data from the same direction and distance at a given time. MasPar MP-1 also provides a global broadcast network and an OR-Reduction network to allow efficient communication between the ACU and the array of PEs. We used the MasPar Parallel Language (MPL) [S] to implement the algorithms. The MPL is an extension of the C language and has a primary feature of adding the keyword plural to a C data-declaration statement. A plural variable is

B. Boldon et al. /Parallel Computing 22 (1996) 369-382

375

allocated computed statement processors statement

on each PE, and any expression that involves a plural variable is simultaneously on the PEs. Statements under a plural-if statement (the if (cond), where cond is a plural expression) is executed only by those that evaluate the condition cond to true. In an MPL program this can be used to selectively activate or deactivate processors.

3.2. Implementation of the heuristics Traditionally, massively-parallel SIMD machines like the MasPar have been found suitable for implementing only those algorithms that have well-structured computation-graphs - such as the ones for sorting, image processing, raster graphics, and dense-matrix computations. Most of these algorithms are systolic (or. can be converted to an efficient systolic algorithm easily) and are therefore obvious SIMD candidates. On the other hand, graph problems (even when they have fast PRAM algorithms) do not usually lend themselves to conversion into neat systolic algorithms. The strategy adopted in our parallel implementation is first to design a suitable PRAM algorithm, and then directly implement on the MasPar MP-1. Typical PRAM operations such as the concurrent-read or the concurrent-write are replaced by suitable routines from the MasPar library. Such a strategy disregards the underlying interconnection architecture of the machine but retains the spirit, elegance, and efficiency of the underlying PRAM algorithms. It is similar to the approach used by HSU, Ramachandran, and Dean who have studied implementations of a few elementary graph algorithms on the MasPar MP-1 [16,17]. The MP-1 implementation of the two phases of our heuristics follow.
MST computation

The MST computation phase takes the weight matrix of a graph as input and finds its minimum spanning tree using an adaptation of Prims algorithm (known to be efficient for dense graphs [25]). For an n-node graph, II I 8192, the first n processors of the MP-1 mesh are employed - the processors numbered in a row-major order. The i-th processor stores the ith row of the weight matrix. The MST computation starts with a single node and grows the tree by adding a new node in each step. Every step finds a global minimum (to determine the node to be added next in the spanning tree) using the MasPar function reduceMin() [8]. The MP-1 execution-time for the MST computation is dominated by (n - 1) calls to the function reduceMin0, for an n-node graph. Function reduceMin() exploits the logarithmic-depth (OR-Reduction) network between the ACU and array of PEs [81. In view of the slow, 4-bit individual processors of the MasPar MP-1, the execution times for MST computation are impressive. Each MP-1 processor is estimated to have a peak performance of only 1.6 MIPS as opposed to 38.5 for the 50 MHz SparcStation II processor 3 (for 32-bit integer instructions). The following

3 Established by aburto@octopus.nosc.mil

Al

Aburtos

Dhrystone

(Version

1.1)

benchmarks.

Dec.

93,

email:

376

B. Boldon et al. /Parallel

Computing 22 (I 996) 369-382

comparison may be instructive: On a SUN SparcStation II the best MST program for a graph with 8192 nodes and 0.75 million edges was reported to have taken 3 seconds [25]. Our MP-1 program for MST of a graph with 5000 nodes and about 12.5 million edges took about 1 second, employing 5000 processors.
Blacklisting

The spanning tree obtained at the end of MST computation is stored by letting each processor Pi, 1 pi I (n - l), store the edge that is incident both to the i-th node and its parent. The node numbered 0 is considered as the root. Thus, every tree edge is allocated to a unique processor. Degree of a node i in the spanning tree, to be stored in Processor P,, 0 I i I (n - l), is computed in three CRCW PRAM steps. First, every processor P, in parallel initializes the degree of node i to 0. Then, each processor, P,, 1 pi I (n - l), in parallel writes a 1 in the local memory of the processor storing the degree of the parent of node i; where the multiple writes to a particular memory location is resolved by summing all the values being attempted to be written. This step is implemented using the MasPar function sendwithAdd() 181. Finally, each processor, P,, 1 I i I (n - 11, increments the degree of node i by 1. Computations of the parameters w,,, and w,,, employ the MasPar functions reduceMin0 and reduceMax(), respectively. Once all the spanning-tree parameters are computed, each processor (except the one numbered 0) computes the new weight of its tree edge if the edge is incident to an infeasible node.

4. Experimental results

Detailed experiments were carried out to demonstrate the effectiveness of our new approach and to determine the best of the four blacklisting functions. Following inputs were used: (i) random weighted graphs with MST having high maximum-degree; (ii) TSP benchmark problems from the Traveling Salesman Problem LIBrary (TSPLIB) [28]. In the discussion to follow each of the four heuristics is referred by its blacklisting function.
4.1. Random weighted graphs

Empirical observations show that a large randomly-generated weight-matrix seldom has MST with the maximum degree exceeding 3 or 4. Hence, the following procedure was used to ensure that the maximum degree in the MST is governed by user-defined parameters: (i) z, the number of nodes with large degree; (ii) d and d, the lower and the upper values, respectively for the degree of the large-degree nodes. A weight matrix is generated by first determining its n-node MST. This tree is constructed by first forming a forest of z different stars - each star with the number of nodes in the range d to d. Then, (z - 1) edges are generated randomly for connecting these stars to form a tree. Since the tree constructed so

B. Boldon et al. /Parallel Computing 22 (I 996) 369-382

2 .s ; c WI E -ii .9 f g E i, 1.7 16 1.5 1.4. 1.V 12 1.1. 1.0 lml B ._ f3 z e E

377

I 100

3000

4000

5000

1000

2000

3000

4omJ

5000

n
-m-BFl BFZ --ABF3

n
--A-

BF4

Fig. 2. Results on random weighted graphs: (a) quality of 5-MST. (b) MP-1 execution-times.

far may have fewer than n nodes, an n-node tree is formed by adding new nodes and edges (randomly). This n-node tree forms the MST of the n-node complete graph. Weights of the tree edges in the n x IZ weight matrix are assigned random values in the range 0.0 to 0.1 and the remaining off-diagonal elements, in the range 0.1 to 1.0. The diagonal elements get a value 03. Figs. 2(a) and 2(b) show the quality of solutions and execution-times, respectively for 5-MSTs (spanning trees with a degree bound 5) on random weighted graphs with the number of nodes, n, varying from 1000 to 5000. The maximum degree of the MST for these graphs was either 20 or 21. (Thus, it was ensured that significant computation was required to obtain 5-MSTs.1 We used the ratio 5-MST weight/MST weight as an approximate measure for the quality of 5-MSTs since optimal solutions for these graphs were not known. It may be noted that the MST weight is a lower bound on the weight of a d-MST, for all d. For every order, n, data-points in Fig. 2 are averages over a large number of graphs - large enough to ensure low standard deviations. For graphs of all orders, every blacklisting function found 5-MSTs within 45% to 70% of the MST weight. Of the four functions, BF2 consistently found 5-MSTs with the least weight. Solution quality of BFl (the blacklisting function modified to get BF2) was only marginally worse than BF2. On the other hand, the probabilistic blacklisting functions (BF3 and BF4) found 5-MSTs with weights considerably higher than the other two functions. Another noteworthy observation is that BF2 outperformed BFl, and similarly BF4 outperformed BF3. This suggests that the rationale of not penalizing the smallest-weight edge incident to every infeasible node improves the performance of a blacklisting function. The number of iterations for each blacklisting function increased slowly with n. The largest increase observed was that for BF3: at n = 1000 the average number of iterations required was 5 whereas at n = 5000, it was mere 9. Since the MST computation (a common phase) dominated the overall execution-times, there are only marginal differences in MP-1 execution-times due to the blacklisting-functions

378

B. Boldon et al. /Parallel Computing 22 (1996) 369-382

BF4
1.01

11

13

15

17

19

Degree bound (d)

Fig. 3. Quality of solutions on random graphs with varying degree bound.

themselves, as evident from Fig. 2(b). Of the four functions, BF4 was the fastest for higher values of n. However, the quality of solutions for BF4 was not competitive with BFl or BF2 - the functions next best in execution-time. Our analysis show that all execution-times per iteration can be approximated by O(n>, 0.5 I E I: 1, for the values of n used. Recall that our parallel implementation employed n processors for a graph on it nodes. Fig. 3 shows how the quality of solutions for the four heuristics change as the degree bound, d, increases from 5 to 19 for a fixed order n = 3000. Since the MST for these input graphs had the maximum degree 20 (or 21) we plotted the quality of solutions only up to d = 19. For d = 21, the d-MST problem becomes unconstrained and every heuristic found a 21-MST with the same weight as the MST. As the degree bound is increased the quality of solutions produced by BFl and BF2 improve by a greater amount as compared to the other two heuristics. The weights of the 19-MSTs for BF3 and BF4 were nearly 50% to 60% above the MST weight as opposed to only 25% for BFl and BF2. 4.2. TSP benchmark problems Table 1 summarizes the results on selected TSP benchmark problems. Since a traveling salesman tour without the last edge (that brings back the salesman to the starting city) is a 2-MST, the TSP-tour weight is an upper bound on the weight of a d-MST, for all values of d. The TSPLIB data-sets were procured from the ftp-site so f t 1 i b . c s . r i c e . e d u . This library of eighty-four test problems is by far the richest and was compiled by Reinelt [28] after the CRPC workshop in 1990. The size of problems in Table 1 ranges from 264 to 5934 - the number in the name of a problem signifying the number of nodes in the graph. All these problems are on points in a plane. For such problems MST-weight _<TSP-weight I 2 X MST-weight (see [61X The maximum degree in the MST for these graphs was found equal to 4; and each blacklisting function was employed to find a 3-MST. (For points in a plane there always exists a 5-MST with weight same as that of an MST, as shown by Khuller et al. 1191.)

B. Boldon et al. /Parallel Computing 22 (1996) 369-382 Table 1 3-MSTs on TSP benchmark Problem a Upper bound (TSP) 49135 6773 48912 252948 270199 62128 336556 378032 137694 _

379

problems Lower bound (MST) 41142 6246 42487 222849 239986 56541 294627 342269 127302 513952 41148 6315 42579 223218 240139 57033 301052 375980 130383 517845 41143 6265 42545 222982 240139 56657 295786 343657 127753 515139 42039 6374 42998 223374 24 1435 58188 30468 1 343789 130958 527150 41143 6265 42563 222982 240236 56663 295739 378032 127731 515235 0.19 0.38 0.43 1.17 1.29 3 75 1.69 3.06 3.88 28.26 Weight BFl BF2 of 3-MSTs b BF3 BF4 Time (sec.)

pr264.tsp rat575.tsp d657.tsp rl1304.tsp r11323.tsp d1655.tsp vm1748.tsp pr2392.tsp pcb3038.tsp r15934.tsp

a The number in the name of the problem signifies the size e.g., pr264.tsp is a 264-node graph h Best solutions are underlined e.g., 41143 for pr264.tsp. Corresponds to the average of execution times for all heuristics that found the best solution.

For each problem, the best TSP-tour-weight known (available in TSPLIB) and the MST-weight (computed by us) are shown in Columns 2 and 3. The next four columns show the weights of 3-MSTs obtained by the four blacklisting functions. The MP-1 execution-times are shown in the last column. In all, forty TSP benchmark problems were used; however, here we report on only a subset of them. (The subset was chosen to span the full range of problem sizes except the ones with it < 200). For each problem in Table 1, the best 3-MST among the four heuristics has weight within 0.5% of the MST. (Readers may note that Khuller et al.? 3-MST algorithm for points in a plane has a performance bound of 50% above the MST weight [19].) The TSP-tour weights when compared to the 3-MST weights are significantly higher. For eight out of ten problems in Table 1, BF2 found 3-MSTs with the least weight. Note that this superior performance of BF2 is consistent with that on even random weighted graphs. The MP-1 execution-times were a few seconds for even the largest problem - a graph with 5934 nodes and nearly 18 million edges. However, it must be pointed that for five out of the forty instances we used, no feasible solutions were found in 200 iterations by one or more blacklisting functions. These instances either require a large number of iterations, or the heuristics do not converge to a feasible solution for them.
5. Discussion

We developed four heuristics for approximate solutions to the d-MST problem and studied their parallel implementations on the MasPar MP-1. All the heuristics are iterative, in which each iteration consists of two steps: (i> computing an MST, disregarding the degree constraint, in the graph with edge-weights modified in the

380

B. Boldon et al. /Parallel

Computing 22 (1996) 369-382

previous iteration; (ii) increasing the weights of those tree edges that are incident to nodes with the degree exceeding d. The graph with the newly modified weights is used in the next iteration. Imposition of penalty on constraint-violating edges in each iteration makes the next spanning tree have fewer degree violations. This approach, of iteratively refining constrained MSTs by penalizing weights of constraint-violating tree-edges, applies to other problems such as the capacitated spanning tree (Problem ND5 in [13]) and the optimum-communication spanning tree (Problem ND7 in [13]). Empirical studies for these two problems are being currently undertaken. Parallelism inherent in the heuristics was exploited by employing as many MP-1 processors as the number of nodes in the input graph. The execution-times and the quality of solutions for the heuristics were studied on two classes of inputs: (i) randomly-generated weighted-graphs with MST having high maximum-degree; (ii) standard TSP benchmark problems. Heuristic BF2 was found to be the best since it produced spanning trees that at an average had the smallest weight (among the four heuristics) for both the classes of inputs. On the TSP benchmark problems, BF2 found 3-MSTs which at an average had weight within 0.5% of the MST and took only a few seconds even for the largest instance - a 5934-&y problem. Although the execution time for BF2 was not the lowest, its superior quality of solution outweighs the speed of the faster heuristic (BF4). In Heuristics BF2 and BF4, for every degree-violating node, the tree edge with the smallest weight among all tree edges incident to that node was not penalized. From our empirical results it is clear that this idea improves the quality of solutions. An interesting extension would be to not penalize a set of low-weight edges (incident to every degree-violating node) instead of just the smallest-weight edge - the number of unpenalized edges per degree-violating node being proportional to the given degree bound. Solutions produced by BF3 and BF4 were hinged on the probability distribution governing the generation of random numbers. A simple linear function was used in our study. It would be interesting to see how well other functions (such as the logarithmic or the square-root functions) perform. The number of iterations of the heuristics presented depends primarily on the underlying blacklisting function. Establishing bounds on the number of iterations for these heuristics remains an open theoretical area. A systematic study of blacklisting functions with provably faster convergence than others merits future investigation. As a start, properties of those TSP benchmark problems for which no 3-MST was found by one or more heuristics in 200 iterations will be analyzed. Understanding the properties for these inputs may lead to the development of better d-MST heuristics.
References [II R.K. Ahuja, T.L. Magnanti and J.B. Orlin, Network Flows: Theory, Algotithms
(Prentice-Hall, Englewood Cliffs, NJ, 1993) Ch. 13.
and Applications

B. Boldon et al. /Parallel Computmg 22 (1996) 369-382

381

[2] B. Boldon. N. Deo and N. Kumar, Minimum-weight degree-constrained spanning tree problem: Heuristics and implementation on an SIMD parallel machine, Technical Report, Dept. of Comp. Science, Univ. of Central Florida, Orlando, CS-TR-95-02, Jan. 1995. [3] P.M. Camerini, G. Galbiati and F. Maffioli. Complexity of spanning tree problems: Part I, Eur. J Oper. Res. 5 (1980) 346-352. [4] P.M. Camerini. G. Galbiati and F. Maffioh, On the complexity of finding multi-constramed spanning trees, Disc. Appl. Math. 5 (1983) 39-50. [5] P.M. Camerini, G. Galbiati and F. Maffioli, The complexity of weighted constrained spanning trees, m: Proc. Colloq. on the Theory of Algoronthms,P&s 1984 (1984) (Janos Bolyai Mathematical Society, Budapest 1984). (61 T.H. Cormen, C.E. Leiserson and R.L. Rivest, Introductton to Algorithms (MIT Press, 1993) Ch. 37. [7] S.K. Das and C.Q. Yang, Performance of parallel spanning tree algorithms on linear array of transputers and Unix systems, Par. Comput. 17 (July 1991) 527-551. [8] DECmpp Users Guide (Programmmg Language, System Ot~erc~tew) (1992). [9] N. Deo and S.L. Hakimi. The shortest generalized Hamiltonian tree. in Proc. 6th Ann. Allerton Conf (1968) 879-888. [lo] N. Deo and Y.B. Yoo, Parallel algorithms for the mmimum spanning tree problem, in Proc Int Conf Par. Process. (Aug. 1980) 243-253. [ll] C.N. Fiechter, A. Rogger and D.D. Werra, Basic ideas of tabu search with an application to traveling salesman and quadratic assignment, Rtcerca Operatica 62 (1992) 5-28. [12] M. Fiirer and B. Raghavachari, Approximating the minimum degree spanning tree to within one from the optimal, Proc. 3rd Ann. ACM-SLAM SODA (1992) 317-324. [13] M.R. Garey and D.S. Johnson, Computers and Intractabihty: A Gurde to the Theory of NP-completeness (W.H. Freeman, San Francisco, 1979). [14] F. Glover. D. Klingman and R. Krishnan. An in-depth empirical investigation of non-greedy approaches for the minimum spanning tree problem, Eur J. Oper. Res. 56(3) (1992) 343-353. [15] R.L. Graham and P. Hell, On the history of mimmum spanning tree problem Annals Hist. Comput. 7(l) (1985) 43-57. [16] T.S. Hsu and V. Ramachandran, Efficient implementation of virtual processing for some combinatorial algorithms on the MasPar MP-1, in Proc. 7th IEEE Symp. Par. Dist. Process., San Antonto (Oct. 1995). [17] T.S. Hsu, V. Ramachandran and N. Dean, Implementation of parallel graph algorithms on MasPar. m DIMACS Series in Discrete Mathemattcs and Theoretical Computer Sctence 15 (1994) 165-198. Computational Support for Discrete Mathematics, DIMACS Workshop, March 12-14. 1992. [18] D.W. Jones, An empirical comparision of priority-queue and event-set implementations. Comm ACM 29 (1986) 300-311. [19] S. Khuller. B. Raghavchari and N. Young, Low degree spanning tree of small weights. Proc 26th Ann. ACM STOCS (1994) 412-421 (to appear in SLAM J. Comput.). [20] M. Krishnamoorthy, A. Suess, M. Onghena, F. Oxaal and T. Spencer, Improvements to GraphPack: A system to manipulate graphs and digraphs, in DIMACS Senes in Discrete Mathemattcs and Theoretical Computer Science 15 (1994) 279-296. Computational Support for Discrete Mathematics, DIMACS Workshop, March 12-14, 1992. [21] F. Malucelli, Quadratic assignement problems: Solutions methods and applications. Ph.D. Dissertation. Dipartmento di Informatica, Universita di Pisa, 1993. [22] B.M.E. Moret and H.D. Shapiro, On minimizing a set of tests, SLAM J. Set. Stat. Comput. 6(4) (1985) 983-1003. [23] B.M.E. Moret and H.D. Shapiro, An empirical analysis of algorithms for constructing minimum spanning tree, LNCS 519 (1991) 400-411. [24] B.M.E. Moret and H.D. Shapiro, How to construct a minimum spanning tree in practice, LNCS 555 (1991) 192-203. [25] B.M.E. Moret and H.D. Shapiro, An empirical assessment of algorithms for constructing a minimum spanning tree, in DIMACS Series m Discrete Mathematics and Theoretical Computer

382

B. Boldon et al. /Parallel Science 15 (1994) 99-117.

Computing 22 (1996) 369-382

Computational Support for Discrete Mathematics, DIMACS Workshop, March 12-14, 1992. 1261 C.H. Papadimitriou and U.V. Vazirani, On two geometric problems related to traveling salesman problem, J. Alg. 5 (1984) 231-246. [27] R. Ravi, M.V. Marathe, S.S. Ravi, D.J. Rosenkrantz and H.B. Hunt III, Many birds with one stone: Multi-objective approximation algorithms, Proc. 25th Ann. ACM STOCS (1993) 438-447. [28] G. Reinelt, TSPLIB - A Traveling Salesman Problem library, OR&l J. Comput., 2(4) (1991) R.E. Stearns and P.M. Lewis II, An analysis of several heuristics for the traveling salesman problem, SLAM J. Comput. 6(3) (1977) 563-581. [30] J. Skorin-Kapov, Tabu search applied to the quadratic assignment problem, ORSA J. Comput. 2
(1990). 376-389. [29] D.J. Rosenkrantz,