Decomposition algorithms for the maximum-weight connected graph problem

Decomposition Algorithms for the Maximum-WeightConnected Graph Problem

Heungsoon Felix Lee,1 Daniel R. Dooly2

1 Department of Mechanical and Industrial Engineering, Southern Illinois University,Edwardsville, Illinois 62026-1805, USA

2 Department of Computer Science, Washington University, St. Louis,Missouri 63130, USA

Received April 1997; revised April 1998; accepted 1 May 1998

Abstract: Given a positive integer R and a weight for each vertex in a graph, the maximum-weight connected graph problem (MCG) is to find a connected subgraph with R verticesthat maximizes the sum of their weights. MCG has applications to communication networkdesign and facility expansion. The constrained MCG (CMCG) is MCG with a constraintthat one predetermined vertex must be included in the solution. In this paper, we introducea class of decomposition algorithms for MCG. These algorithms decompose MCG into anumber of small CMCGs by adding vertices one at a time and building a partial graph.They differ in the ordering of adding vertices. Proving that finding an ordering that givesthe minimum number of CMCGs is NP-complete, we present three heuristic algorithms.Experimental results show that these heuristics are very effective in reducing computa-tion and that different orderings can significantly affect the number of CMCGs to be solved.q 1998 John Wiley & Sons, Inc. Naval Research Logistics 45: 817–837, 1998

1. INTRODUCTION

Consider an undirected graph G Å (V, E) , where V is a set of vertices and E is a set ofedges between some pairs of vertices in V, and each vertex has an associated weight £i .The maximum-weight connected graph problem (MCG) is to find a connected subgraphwith R vertices which maximizes the sum of their weights ( in short, we say their weightsum). The constrained maximum-weight connected graph problem (CMCG) is to solveMCG with the additional constraint that a predetermined vertex must be included in thesolution. We call this predetermined vertex a fixed vertex. In this paper we introducealgorithms for MCG that can significantly reduce computation by decomposing MCG intoa number of smaller CMCGs.

We also address a variant of MCG, MCG with edge costs (MCGEC). With a costassigned to each edge in E , MCGEC is to find a connected subgraph that maximizes thesum of vertex weights in the subgraph subject to a constraint that a total edge cost should

Correspondence to: H. F. LeeContract grant sponsor: National Science Foundation; contract grant number: DDM-9201954Contract grant sponsor: Southern Illinois University at Edwardsville

q 1998 by John Wiley & Sons, Inc. CCC 0894-069X/98/080817-21

8m28 998/ 8M28$$0998 10-06-98 14:05:51 nra W: Nav Res

818 Naval Research Logistics, Vol. 45 (1998)

not exceed R *. We will show that MCGEC can be transformed into MCG, and thereby theproposed decomposition algorithms can be applied to MCGEC.

MCGEC has applications to communication network design and facility expansion. Sup-pose we have designed a fiber-optic communication network connecting the node set V,and wish to build it over T periods. The topology of the designed network is representedby G Å (V, E) . The nodes are assigned weights reflecting their degree of importance. Dueto, for example, a budget constraint, we want to gradually expand the network over multipleperiods. In each period, we have a budget which allows us to add edges with costs totalingat most R * plus the unspent budget from previous periods, such that the resulting network(subgraph of G) is connected, maximizing total weight over T periods. The budget constraintlimits the amount of network expansion for each period. Lee and Dooly [12] present threeheuristic algorithms for this problem. Each of these algorithms uses MCGEC as a subroutinefor their solution methods. For example, the simplest greedy-style heuristic applies MCGECat the first period and then from the second period on applies the constrained MCGEC bytreating all nodes added in the previous periods as one consolidated fixed node. Twoother heuristics require solving MCGEC several times. Thus, the decomposition algorithmsproposed in this paper can reduce computation to solve this network expansion problem.

It is NP-hard to find a connected graph on a given number of vertices that either maximizesor minimizes the sum of the vertex weights, even if these weights are all 0 or 1 [7] . MCGis strongly NP-complete even when a graph is a partially complete bipartite graph. We canprove this by polynomially transforming the exact cover by 3-sets problem [4] to this MCG.However, MCG is polynomial on special graphs such as trees and layered graphs [7, 11].For CMCG for general graphs, Lee and Dooly [11] provide a mathematical programmingmethod and a Balas-style implicit enumeration algorithm and present experimental resultswith them.

Goldschmidt and Hochbaum [7] study the k-edge incident problem which maximizesthe total weight on the nodes on a subgraph that spans up to k edges, where an edge isconsidered to be spanned by a subgraph if at least one of its endpoints is in the subgraph.They show that the problem is strongly NP-hard, and give approximation algorithms forunweighted and weighted graphs and a polynomial time exact algorithm under specialgraphs.

Several researchers study the k minimum spanning tree (k-MST) problem for a graphwith edge costs that seeks a minimum spanning tree containing k unweighted nodes. Raviet al. [14] prove that this problem is NP-hard. Garg and Hochbaum [6] provide an O( logk) approximation algorithm to this problem in the Euclidean plane. On general graphs, Raviet al. [14] provide an O(3

√k) approximation algorithm and Awerbuch et al. [1] provide

an improved O( log2 k) approximation algorithm. Also see Blum et al. [2] for a constantfactor approximation algorithm for the k-MST problem and Garg [5] for its improvedapproximation algorithm. Given a k-MST problem, we can transform it to an instance ofthe MCGEC. To do this, we first guess a value R* for the cost of the k-MST solution andsearch for the smallest value of C * such that there is a feasible solution to the MCGECwith this value of C * and with the number of nodes R Å k . Another related problem is themaximum density problem that maximizes the density of a subgraph with k nodes, wherethe density is the number (or costs) of edges divided by the number (or weights) of thenodes in the subgraph. This problem is also NP-hard and Kortsarz and Peleg [10] presentan O(n 0.3885 ) approximation algorithm. Refer to [7] for other related problems that seek asubgraph with k nodes or k edges under different criteria.

8m28 998/ 8M28$$0998 10-06-98 14:05:51 nra W: Nav Res

819Lee and Dooly: Decomposition Algorithms for Connected Graph Problems

Hochbaum [8] discusses a decomposition method that can be applied to a general classof graph problems. This method first finds biconnected components of a graph and thenuses a dynamic programming algorithm to find an optimal solution for the whole graph,given as subroutine algorithms for constructing solutions on the biconnected components.This method is also applicable to MCG. However, this method is sensitive to the structureof a graph. For example, it does not work when a whole graph forms one biconnectedcomponent, which often happens for dense graphs.

The decomposition methods proposed in this paper take a different approach. Thesemethods add vertices one at a time and process induced subgraphs each time a vertex isadded. They differ in the order of adding vertices, and we will show that a different orderingcan significantly affect the number of CMCGs that need to be solved. As a result, theproposed methods work for any graph, saving computation over solving MCG for a wholegraph.

The rest of the paper is organized as follows. In Section 2, we show that MCG can bedecomposed into a number of small CMCGs and present exact analyses for a simpledecomposition algorithm. In Section 3, we prove that the problem of decomposing MCG intothe smallest number of CMCGs is NP-complete and introduce three heuristic decompositionalgorithms. In Section 4, we present experimental results with them. In Section 5, weintroduce MCGEC and relate MCGEC to MCG. In Section 6, we conclude with a briefsummary.

2. AN ALGORITHM FOR MCG AND ANALYSIS

The most natural algorithm for MCG for a general graph is a greedy algorithm whichstarts with Vs including only the vertex having the largest weight, then repeatedly addingto Vs the next vertex which has the largest weight among vertices adjacent to Vs until ÉVsÉ

Å R . This greedy algorithm for MCG has an unbounded error in the worst case, where thedifference between the optimal and greedy solutions increases as R increases. In fact, noapproximation with factor better than O(R) is known [7].

We take a different approach for solving MCG. This approach consists of a main proce-dure and a subroutine. The main procedure systematically fixes one vertex and calls thesubroutine to solve CMCG. First, we let Gi be the subgraph of G induced by the first ivertices and Gi Å (Vi , Ei ) be the component of Gi containing the i th vertex. Then for i ¢3, Gi01 consists of one or more components. When the i th vertex is added to Gi01 , thevertex may have edges to vertices in some components and the graph resulting from joiningthese components with the i th vertex and such edges becomes Gi . Now we state the mainprocedure as follows:

Algorithm MAIN: An algorithm for MCG

Input: G Å (V, E) , ÉVÉ Å n , R , and a nonnegative weight £i at vertex i for all iOutput: the optimal solution, Vs and its weight sum, z

for i Å R to n , do beginif ÉViÉ ¢ R , then begin

Solve CMCG for Gi with vertex i fixedupdate z and Vs if a better solution is found

end {if}end {do}

8m28 998/ 8M28$$0998 10-06-98 14:05:51 nra W: Nav Res


Figure 1. A connected graph with 10 vertices.

THEOREM 1: Algorithm MAIN finds an optimal solution to MCG when CMCG isoptimally solved.

PROOF: Suppose that V *s is an optimal solution to MCG. Let vertex i be the last vertexadded among the R vertices in V *s . When vertex i is added, the other R 0 1 vertices havealready been assigned and exist in one or more components. Since V *s is connected, theresulting graph Gi includes all vertices in V *s . Let z be the weight sum of an optimalsolution to this CMCG with vertex i fixed. Since V *s is a feasible solution to the CMCG,the weight sum of V *s ° z . Since V *s is an optimal solution to MCG, z ° the weight sumof V *s . Thus, the result follows. h

Algorithm MAIN with the result of Theorem 1 reduces computation over completeenumeration (solving CMCGs n times) , since the number and size of CMCGs that areactually solved in the algorithm can be small. This is shown in the following example andby the analysis for random graphs below.

EXAMPLE 1: The graph in Figure 1 has 10 vertices with parameter weights specifiedas follows: R Å 5 and £i Å 11 0 i for i Å 1–10. The detailed execution of Algorithm 1is summarized in Table 1. CMCG needs to be solved only three times, once each for theaddition of vertices 8, 9, and 10. According to Theorem 1, the optimal solution to MCG isthe best among the optimal solutions to the three CMCGs, that is, the optimal solution toCMCG with vertex 8 fixed.

For a special random graph, we can derive the expected number and the expected size(in terms of the number of vertices) of CMCGs to be solved by Algorithm MAIN.

DEFINITION 1: Random graph, RG(n) , is defined as graph GÅ (V, E) with the followingproperties: V Å {1, 2, . . . , n} and E Å {( i , X ( i)) , i Å 1, 2, . . . , n}, where ( i , j) is anedge leaving from i to j and the X ( i) are independent random variables such that probabilityP(X ( i) Å j) Å 1/n for j Å 1, 2, . . . , n . In other words a random graph is constructed by,for each vertex, selecting at random one of the n vertices (including the vertex i itself) andthen joining vertex i and the selected vertex with an edge.

LEMMA 1:

P(random graph RG(n) is connected) Å (n 0 1)!nn ∑

n01

jÅ0

n j

j![15].

8m28 998/ 8M28$$0998 10-06-98 14:05:51 nra W: Nav Res


Table 1. An example of the main procedure for MCG.

Vertex added Sets of vertices in disconnected components

1 {1}2 {1}, {2}3 {1}, {2,3}4 {1}, {2,3,4}5 {1,5}, {2,3,4}6 {1,5}, {2,3,4,6}7 {1,5}, {2,3,4,6}, {7}8 {1,2,3,4,5,6,7,8}

Solve CMCG with vertex 8 fixedoptimal solution Å {1,2,5,6,8},a weight sum Å 33;this becomes the incumbent solution for MCG

9 {1,2,3,4,5,6,7,8,9}

Solve CMCG with vertex 9 fixedoptimal solution Å {2,3,4,6,9}, weight sum Å 31;not better than the incumbent solution for MCG

10 {1,2,3,4,5,6,7,8,9,10}

Solve CMCG with vertex 10 fixedoptimal solution Å {1,2,3,6,10}, weight sum Å 33;not better than the incumbent solution for MCG

a {1,2,3,5,6,8} is the optimal solution for MCG.

DEFINITION 2: Random graph, RG(r , x) , is defined as a graph with r / 1 vertices {0,1, . . . , r} and r edges {( i , Yi ) , i Å 1, . . . , r}, where P (Yi Å 0) Å x / (r / x) and P (Yi

Å j) Å 1/(r / x) for j Å 1, . . . , r .

LEMMA 2: P(random graph RG(r , x) is connected) Å x / (r / x) [15].

THEOREM 2: If G Å (V, E) is random graph RG(n) , then the expected number ofCMCGs to be solved by Algorithm MAIN, denoted as E(N) , is given as

E(N) Å ∑n

iÅR

∑i

kÅRS i 0 1

k 0 1D (n 0 k) i0k

n i H(k 0 1)! ∑k01

jÅ0

k j

j!/ (n 0 i)kk

k / 1 J .

PROOF: Since Algorithm MAIN solves CMCG for Gi Å (Vi , Ei ) when there are R ormore vertices in Vi , the expected number of CMCG to be solved for Gi equals P(ÉViÉ ¢R) . Thus, we have

E(N) Å ∑n

iÅR

P(ÉViÉ ¢ R) Å ∑n

iÅR

∑i

kÅR

P(ÉViÉ Å k) .

Consider k vertices, say, vertex i and vertices 1, . . . , k 0 1 for i ¢ k . Then, probabilitythat Vi consists of these vertices, that is, probability that subgraph Gi induced by thesevertices is a connected component of Gi Å (V i , Ei ) , where V i Å {1, . . . , i}, is given as

8m28 998/ 8M28$$0998 10-06-98 14:05:51 nra W: Nav Res


P (Vi Å { i , 1, . . . , k 0 1})

Å P(Gi is a connected component of GO i )

Å P( there is no edge between Vi and VO i 0 Vi , and Gi is connected)

We define two events A and B as follows: Event A occurs when no edge leaves from V i

0 Vi to Vi [ i.e., X ( j) √/ Vi for each j √ Vi 0 Vi ] , and Event B occurs when no edgeleaves from Vi to V i 0 Vi [ i.e., X ( j) √/ V i 0 Vi for each j √ Vi ] . Then,

P (Vi Å { i , 1, . . . , k 0 1})

Å P(Events A and B occur, and Gi is connected)

Å S n 0 k

n Di0k

P(Event B occurs and Gi is connected)

(from independence of X ( j)’s)

Å S n 0 k

n Di0k

∑k

mÅ0

P(Event B occurs and Gi is connectedÉM Å m)P(M Å m) ,

where we let M indicate the number of edges that leave from Vi to V 0 Vi . Since at leastk 0 1 edges are required to have a graph with k vertices connected,

P(Event B occurs and Gi is connectedÉM Å m) Å 0 for m ¢ 2,

P(Event B occurs and Gi is connectedÉM Å 0) Å P(Gi is connectedÉM Å 0)

Å P(RG(k) is connected) Å (k 0 1)!kk ∑

k01

jÅ0

k j

j!(from Lemma 1),

P(Event B occurs and Gi is connectedÉM Å 1)

Å P(Gi is connectedÉEvent B occurs and M Å 1)P(Event B occursÉM Å 1)

Å P(RG(k , 1) is connected)P(Event B occursÉM Å 1)

Å 1k / 1

n 0 i

n 0 k(from Lemma 2).

Thus,

P (Vi Å { i , 1, . . . , k 0 1})

Å S n 0 k

n Di0kH (k 0 1)!kk ∑

k01

jÅ0

k j

j! S k

nDk

/ 1k / 1

n 0 i

n 0 k Sk

1DS n 0 k

n DS k

nDk01J .

As there are ( i01k01) subsets of size k 0 1 in Gi (excluding vertex i) , we see that P(ÉViÉ Å

k) Å ( i01k01)P (Vi Å { i , 1, . . . , k 0 1}) and the result follows after simplifying terms. h

8m28 998/ 8M28$$0998 10-06-98 14:05:51 nra W: Nav Res


Figure 2. The expected number of CMCGs solved for random graph RG(n) .

LEMMA 3: If G Å (V, E) is random graph RG(n) , then the expected size of CMCGsto be solved by Algorithm MAIN, denoted as E(S) , is given as

E(S) Å ∑n

kÅR

k ∑n

iÅk

P(ÉViÉ Å k)E(N)

.

PROOF:

E(N) Å ∑n

iÅR

∑i

kÅR

P(ÉViÉ Å k) Å ∑n

kÅR

∑n

iÅk

P(ÉViÉ Å k) Å ∑n

kÅR

E(Nk) ,

where E(Nk) is the expected number of CMCGs with size k to be solved by AlgorithmMAIN. Then we have P(Sk) , probability that a CMCG to be solved is of size k , as P(Sk)Å E(Nk) /E(N) . Thus,

E(S) Å ∑n

kÅR

kP(Sk) Å ∑n

kÅR

kE(Nk)E(N)

. h

We computed E(N) and E(S) over numerous combinations of R and n . Figures 2 and

8m28 998/ 8M28$$0998 10-06-98 14:05:51 nra W: Nav Res


Figure 3. The expected size of CMCGs solved for random graph RG(n) .

3 show typical results of E(N) and E(S) over R at n Å 100, 500, and 1000. These figuresalso show that E(N) and E(S) are well approximated by the following curve fits: E(N) f

Å n /(√

R / R 1/√n) õ n /

√R and E(S) f Å

√nR . We consider another type of a ran-

dom graph.

DEFINITION 3: Random graph, RG2(n , p) , is defined as G Å (V, E) where ÉVÉ Å nand each edge is independently introduced with probability p [13].

LEMMA 4:

P(RG2(n , p) is connected) Å P(RG2(n , p)) Å ∑(n

2 )

qÅn01

Cn ,qpq(1 0 p)(n

2 )0 q [13],

where Cn ,q is the number of connected graphs when ÉVÉ Å n and ÉEÉ Å q and isgiven as

(q / 1)Cn ,q/1 Å FSn

2D 0 qGCn ,q / 12 ∑

n01

iÅi

∑q

jÅ1Sn

i D i(n 0 i)Ci , jCn0i,q0 j

for n ú 1 and all q ,

with C1,0 Å 1 and Cn ,0 Å 0 for n ú 1.

8m28 998/ 8M28$$0998 10-06-98 14:05:51 nra W: Nav Res


LEMMA 5: If G Å (V, E) is random graph RG2(n , p) , then E(N) is obtained as

E(N) Å ∑n

iÅR

∑i

kÅRS i 0 1

k 0 1D(1 0 p) ( i0k )kP(RG2(k , p)) .

PROOF: The proof is similar to that of Lemma 2. The difference is in deriving

P (Vi Å { i , 1, . . . , k 0 1})

Å P( there is no edge between Vi and VO i 0 Vi , and Gi is connected)

Å P( there is no edge between Vi and VO i 0 Vi )P(Gi is connected)

Å (1 0 p) ( i0k )kP(RG2(k , p)) . h

Computing E(N) is not easy for even moderate size n . Values of Cn ,q for n° 8 are availablein [17]. Experimental results of Section 4 show the effects of n , R , and p (graph density)on E(N) . Lemma 3 for E(S) also holds for random graph RG2(n , p) .

3. ORDER OF ADDING VERTICES

In the previous section, we sequentially added vertices according to their vertex numberin order to form Gi’s and determine which CMCGs need to be solved. In this section weinvestigate the effect of the order in which vertices are added. We will show that a differentordering can significantly affect the number of times that CMCGs are solved, and presenttwo ordering algorithms that seek the minimum number of CMCGs to be solved. We firstinvestigate the computational tractability of this ordering problem.

3.1. Computational Tractability for the Ordering Problem

We define the vertex ordering problem as the problem of ordering vertices to be inputto Algorithm MAIN so as to minimize the number of resulting CMGC problems to besolved.

THEOREM 3: The vertex ordering problem is NP-complete.

PROOF: Let ADD_VERTEX (G , R , N) be any algorithm for finding an ordering of thevertices of G for which the number of times CMCG is called is less than or equal to N , ifpossible. A solution to ADD_VERTEX can be verified in polynomial time, since this merelyrequires counting the number of vertices in a component of the restricted graph, once foreach node in the graph. Recall that CMCG is called whenever Gi has at least R vertices.Consider an ordering in which Gi has fewer than R vertices and Gi01 has at least R vertices.We create a new ordering by switching £i01 and £i . Since £i01 [ i.e., the ( i 0 1)th addedvertex] is not in Gi , the number of CMCG calls in this new ordering remains the same asthat in the original ordering. We continue to switch such pairs of vertices until no such apair exists. This gives an ordering in which all vertices whose addition causes a CMCGcall are added only after all vertices whose addition does not cause a CMCG call. That is,with a polynomial-time transformation of ADD_VERTEX, we can find an ordering of the

8m28 998/ 8M28$$0998 10-06-98 14:05:51 nra W: Nav Res


vertices in which we can add at least ÉVÉ 0 N vertices, if possible, before we get acomponent containing R vertices. The decision problem for INDEPENDENT_SET iswhether a graph contains a set of N * Å ÉVÉ 0 N vertices with no edge connecting anytwo of them. In particular, if R Å 2, this means that, with a polynomial-time transformationof ADD_VERTEX, we can solve INDEPENDENT SET, which is NP-complete [4] . h

3.2. Heuristic Algorithms

We consider two ordering heuristic algorithms for choosing vertices, ORIGINAL_DEGREEand UPDATED_DEGREE, and a random method of choosing vertices, RANDOM. Algo-rithm ORIGINAL_DEGREE first adds vertices whose addition does not cause a CMCGcall. Among all such vertices, it chooses one with the smallest degree. If addition of anyvertex causes a CMCG call, the algorithm chooses a vertex that will minimize the CMCGsize. If there is a tie, it chooses one with the smallest degree. Choosing nodes with smalldegrees first tends to create a large number of small components, which can result in thesmall number of CMCG calls. The detailed steps of the algorithm appear on the next page.

EXAMPLE 2: We use Figure 1 with R Å 3 to illustrate Algorithm ORIGINAL_DEGREE.

Vertex chosen Components CMCG size

7 {7} 01 {1} {7} 04 {1} {4} {7} 09 {1} {4} {7} {9} 02 {1} {2,4} {7} {9} 05 {1,5} {2,4} {7} {9} 06 {1,5} {2,4,6} {7} {9} 33 {1,5} {2,3,4,6,9} {7} 5

10 {1,2,3,4,5,6,9,10} {7} 88 {1,2,3,4,5,6,7,8,9,10} 10

THEOREM 4: ORIGINAL_DEGREE requires O(n 2 / nEa(nE , n)) time and O(n /E) space, where a(m , n) is the inverse of Ackermann’s function.

PROOF: The outer while loop is done O(n) times. The inner while loop may need tobe done O(n 2) times. The for loop in the inner while loop is done O(E) times per outerwhile loop, or O(nE) times. Finding the component in this for loop is done O(nE) times.Adding the component id to the list of component ids is done O(n) times per outer whileloop or O(n 2) times. With use of a hash table for the component list, finding and searchingcan each be done once in constant time. Everything else in the inner while loop takes O(n 2)time. Adding choice to the set of chosen vertices is done n times. The for loop mergingsets is done a total of O(E) times altogether, twice per edge. Everything else in the outerwhile loop takes O(n) time. With use of efficient disjoint set data structures for components[3] , there are O(nE / n / E) disjoint set operations of which O(E) are mergers, O(nE)are searches, and O(n) make sets. This takes O(nEa(nE , n)) time [16], where a(m , n)is the inverse of Ackermann’s function, and is for all practical purposes almost constant.

8m28 998/ 8M28$$0998 10-06-98 14:05:51 nra W: Nav Res


Algorithm ORIGINAL_DEGREE

Input: G Å (V, E), ÉVÉ Å n, R, and a nonnegative weight £i at vertex i for all iOutput: an ordering of the vertices and the number and average size of CMCG calls.

set count of CMCG calls to 0set sum of sizes of CMCG calls to 0

while there are unadded vertices doset best size to infinityset best degree to infinityset all vertices in list of unadded_vertices to be not traversedwhile there are untraversed vertices in the list of unadded_vertices do

set component size to 1set list of component ids to M.pick an untraversed vertex in the list of unadded_vertices to be current vertexset current vertex traversedfor each edge touching current vertex do

find component for the other vertex of this edgeif other vertex has been added and component containing othervertex is not in list of components connected to current vertex then

add component id to the list of component idsadd size of component to component size

end [if]end [for]if component size õ R and (best size ¢ R or vertex degree õ best degree) then

set choice to current vertexset best size to component sizeset best degree to vertex degree

else if component size ¢ R and {component size õ best size or(component size Å best size and vertex degree õ best degree)} then

set choice to current vertexset best size to component sizeset best degree to vertex degree

end [if]end [while]for each previously added vertex, £, adjacent to choice do

merge components for choice and £

end [for]remove choice from unadded_verticesoutput choiceif size of component containing choice ú R then

increment count of CMCG callsadd size of component to sum of sizes of CMCG

end [if]end [while]output count and average size of CMCG calls

Since the disjoint set structures and the hash table require O(n) space, the total spaceneeded is O(n / E) . h

Algorithm UPDATED_DEGREE is the same as Algorithm ORIGINAL_DEGREE with

8m28 998/ 8M28$$0998 10-06-98 14:05:51 nra W: Nav Res


one difference. Algorithm UPDATED_DEGREE, instead of choosing a vertex with thesmallest degree, chooses the vertex with the smallest remaining degree, where the remainingdegree means the number of edges to other vertices that have not been added yet. In sparsetreelike graphs, this allows building components from the leaves inward. This will avoidcalling CMCG each time a leaf node is added when its parent node was already assignedto a component with at least R 0 1 vertices. The remaining degree is updated each time avertex is added by reducing the degrees of its adjacent vertices by 1. Thus the time andspace complexities remain the same.

EXAMPLE 3: We use the same problem as Example 2 to illustrate AlgorithmUPDATED_DEGREE. Note that the ordering of vertices 2, 5, and 9 differs in the previousexample.

Vertex chosen Components CMCG size

7 {7} 01 {1} {7} 04 {1} {4} {7} 02 {1} {2,4} {7} 05 {1,5} {2,4} {7} 09 {1,5} {2,4} {7} {9} 06 {1,5} {2,4,6} {7} {9} 33 {1,5} {2,3,4,6,9} {7} 5

10 {1,2,3,4,5,6,9,10} {7} 88 {1,2,3,4,5,6,7,8,9,10} 10

THEOREM 5: For a tree, UPDATED_DEGREE solves CMCGs at most 2n / (R/ 1) times.

PROOF: Let H0 be the graph just before CMCG was called for the first time. Anyunchosen node must have at least R 0 1 nodes in the components surrounding it [see Fig.4(a)] . Rearrange the tree so that the root is unchosen. We define a candidate as an unchosennode whose descendants are all chosen. Since UPDATED_DEGREE chooses nodes fromleaves inwards, every candidate must have at least R 0 1 descendants; otherwise it musthave been chosen since its remaining degree is 0 or 1. We make Hi/1 from Hi for i ¢ 0as follows: 1) Choose a candidate and remove the candidate and its descendants from thegraph; 2) if there exist any unchosen ancestors of the candidate, then pick the closest onefrom the candidate and remove it from the graph; and 3) if the removed ancestor had aparent, then make all of that ancestor’s children into children of that ancestor’s parent [seeH1 in Fig. 4(b)] . We have removed at least R 0 1 chosen nodes and at most two unchosennodes. The next-nearest unchosen ancestor of the removed nodes must now have at leastR 0 1 chosen descendants in Hi/1 , because the components surrounding the removedancestor had to contain at least that many nodes or it would have been chosen. Since thisis the only node which can become a new candidate in Hi/1 , all candidates in this newgraph still have at least R 0 1 chosen descendants. When we continue this removal process,we will eventually have a graph with no unchosen nodes [see H3 in Fig. 4(d)] . Since weremove nodes in groups containing at most two unchosen nodes and at least R 0 1 chosen

8m28 998/ 8M28$$0998 10-06-98 14:05:51 nra W: Nav Res


Figure 4. Derivation of trees from H0 to H3 for UPDATED_DEGREE with R Å 4.

8m28 998/ 8M28$$0998 10-06-98 14:05:51 nra W: Nav Res


nodes, we have at most 2n / (R / 1) unchosen nodes in H0 . Thus, algorithmUPDATED_DEGREE solves CMCGs at most 2n / (R / 1) times for a tree. h

THEOREM 6: When the graph is a tree, algorithm UPDATED_DEGREE solves at mosttwice the minimum number of CMCGs.

PROOF: Let Q0 be a minimal set of nodes for each of which a CMCG must be called.For each candidate in H0 , the subtree composed of the candidate and its descendants isconnected and it has at least R nodes, so that this subtree contains at least one node of Q0 .Construct Qi/1 from Qi as follows: (1) Remove from Qi each node that was removed whenHi/1 was constructed from Hi ; (2) if the candidate’s ancestor removed from Hi was in Qi ,then add that ancestor’s parent to Qi/1 . The removed ancestor and the chosen nodes sur-rounding it were connected in Hi and there were at least R of them, so that at least one ofthem was in Qi . The only one of them which could be removed from Qi was the ancestor,and it would be replaced by its parent. Thus, in the subtree composed of any new candidatein Hi/1 and its descendants, there must be a node from Qi/1 . In every step from Qi to Qi/1 ,the number of nodes in Qi decreases at least by 1 and the number of unchosen nodes inHi decreases at most by 2. As a result, the number of unchosen nodes in H0 is at mosttwice the number of nodes in Q0 . h

The above results do not hold for algorithm ORIGINAL_DEGREE. We can construct atree where algorithm ORIGINAL_DEGREE performs worse. For a general graph, however,such an error bound does not exist for either algorithm. This is attributed to a myopic natureof choosing vertices in both algorithms.

Next, we consider Algorithm RANDOM which adds vertices in a random order. Mostcomputation time of RANDOM is spent in disjoint set operations. We can show that thetotal time is about O(n / E) time and the total space is O(n / E) . Although the twoprevious algorithms take more time than RANDOM by order of O(n) , they can be justifiedby solving CMCGs less times. This issue will be further discussed in the following experi-ment section.

EXAMPLE 4: We use Figure 1 with R Å 3, where the node numbers are considered arandomly chosen sequence. From Table 1, CMCGs are solved five times, each time nodes4, 6, 8, 9, and 10 are added. In comparison, the two previous ordering algorithms requiredsolving CMCGs four times.

4. EXPERIMENTAL RESULTS

We conducted experiments to compare the three ordering heuristics UPDATED_DEGREE,ORIGINAL_DEGREE, and RANDOM. In order to generate test graphs, we specified severallevels of parameters n and k , where k is a control parameter for a graph density such thatk(n 0 1) edges are randomly generated out of all possible edges, i.e., (n 0 1)n /2 edges.We used four levels of n , (100, 300, 500, 1000), and three levels of k , (1, 3, 5) . For eachof the 12 possible sets of parameters, we generated nine graphs. We applied each of thethree algorithms to each graph with three levels of R , (10, 20, 40), thus, total 324 MCG

8m28 998/ 8M28$$0998 10-06-98 14:05:51 nra W: Nav Res


Table 2. Experimental results with three ordering algorithms: random graphs.

Updated degree Original degree Random Enumeration

k R n Count Size Count Size Count Size Count Size

1 10 100 11.2 41.8 11.4 41.8 29.1 49.0 82.4 82.5300 35.2 105.1 35.1 104.2 90.7 136.6 241.6 239.4500 59.2 163.2 59.7 163.7 156.6 218.8 401.7 399.9

1000 116.2 317.8 116.2 318.9 311.8 435.6 798.7 797.920 100 7.8 56.5 8.7 54.1 24.8 55.3 82.4 82.5

300 26.2 135.5 26.1 134.6 81.3 150.9 240.4 240.5500 44.7 213.4 44.1 213.6 139.9 243.3 400.7 400.9

1000 88.8 411.7 89.6 405.7 281.8 481.0 798.2 798.440 100 6.2 67.5 6.3 62.4 19.4 61.6 82.4 82.5

300 22.8 163.7 21.3 163.3 73.9 163.0 240.4 240.5500 38.0 264.0 37.2 256.0 132.4 255.8 400.7 400.9

1000 75.7 491.1 74.9 492.6 266.3 507.6 798.2 798.43 10 100 44.0 66.1 41.9 67.7 73.6 60.2 100 100

300 135.7 189.3 128.7 195.6 219.4 178.0 300 300500 221.3 315.8 213.7 319.3 373.1 293.0 500 500

1000 442.4 626.4 424.9 640.6 743.0 586.8 1000 100020 100 42.7 69.4 39.8 71.3 69.1 63.1 100 100

300 131.3 200.9 123.8 205.1 215.4 181.0 300 300500 215.8 331.2 202.2 341.5 364.3 299.7 500 500

1000 431.8 652.8 406.2 677.9 734.1 593.8 1000 100040 100 42.7 72.4 39.1 73.2 55.6 71.0 100 100

300 130.9 203.2 119.7 212.0 209.7 185.2 300 300500 214.8 332.8 197.3 350.3 359.4 303.4 500 500

1000 430.3 661.3 398.4 694.6 728.2 598.3 1000 10005 10 100 59.1 65.8 58.2 65.6 84.6 57.4 100 100

300 180.4 189.6 176.0 193.4 250.2 171.4 300 300500 297.0 315.6 288.2 319.1 421.3 283.2 500 500

1000 596.1 626.3 580.2 634.5 846.0 563.9 1000 100020 100 57.0 68.0 55.9 68.7 77.8 61.2 100 100

300 179.3 193.3 172.3 197.1 246.6 173.7 300 300500 295.7 318.7 284.8 327.7 416.7 286.2 500 500

1000 593.2 634.7 566.1 655.0 841.1 567.1 1000 100040 100 56.4 69.6 54.7 69.5 60.6 70.1 100 100

300 177.3 196.3 168.7 202.4 238.6 178.6 300 300500 294.4 322.6 282.4 330.1 411.4 289.4 500 500

1000 592.6 639.0 566.7 656.0 833.9 571.8 1000 1000

problems. In Table 2, we summarized the average values over nine runs for the numberand size of CMCGs called by the three algorithms. We also collected the same statisticsfor enumeration in order to see the effect of the proposed decomposition algorithms. For aconnected graph with n vertices, enumeration calls CMCGs n times with each CMCG sizeof n . When k Å 3 or 5, almost all graphs generated were connected. When k Å 1, however,graphs were sparser and often had more than one component. When a component size isless than R , enumeration could have less than n CMCG calls with a smaller size.

UPDATED_DEGREE and ORIGINAL_DEGREE indeed called a significantly smallernumber of CMCGs than enumeration. These algorithms had 8–60% as many CMCG callsas enumeration with average 37%. They also had a much smaller size of CMCGs, rangingbetween 40% and 82% with an average of 63%.

UPDATED_DEGREE and ORIGINAL_DEGREE outperformed RANDOM for every

8m28 998/ 8M28$$0998 10-06-98 14:05:51 nra W: Nav Res


tested problem, with most improvement at the sparsest graph. When k Å 1, they had only28% (R Å 40) to 40% (R Å 10) as many CMCG calls as RANDOM. They outperformedRANDOM not only with respect to the number of CMCG calls but also to their averagesize. For eight out of 12 problems, RANDOM had the larger size. Even for the remainingfour problems, the difference of the size was small, not exceeding 10%. For sparse graphs,all the algorithms start by creating many small components. RANDOM then merges someof the small components into two or three larger components, which it soon merges intoone large component. Most of the CMCG calls are made by this large component as itgrows uniformly larger. The other algorithms avoid merging into one large component aslong as they can, so that they have fewer calls adding to one large component. As thedensity increased, the number of CMCG calls increased for all algorithms. When k Å 3,they had 55% and 77% as many CMCG calls as RANDOM. The CMCG sizes, however,were just 102–116% of the sizes of RANDOM. When k Å 5, they had 67% and 93% asmany CMCG calls as RANDOM. The CMCG sizes were 99–115% as large. Higher sizeratios were generally associated with smaller CMCG count ratios.

For all algorithms on all graphs tested, with R and k fixed, the count of CMCGs solvedincreased almost linearly with n . The average degree of a node, k(n 0 1)/n , is almostindependent of n . This means that, locally, all graphs with the same k value resemble oneanother. Whether choosing a node will cause a CMCG call depends on only a subgraphthat consists of nodes within distance R of the node, but not on the rest of the graph. So,the probability that choosing a node will cause a CMCG call seems to be a local property,depending mainly on the percentage of nodes already chosen within the subgraph. Thus, itmakes sense that the increase in CMCG count will be almost linear.

With n fixed, increasing R decreased the CMCG count and increased the CMCG size forall algorithms. This is because CMCG is solved only when its component size is greaterthan R . This effect of R was more apparent for sparser graphs. For example, as R changedfrom 10 to 40 when n Å 1000, the three algorithms (UPDATED_DEGREE,ORIGINAL_DEGREE, and RANDOM) decreased the CMCG count by 35%, 36%, and15%, respectively, under k Å 1, while the decrease was only by 1%, 2%, and 1% under kÅ 5. This is because for denser graphs the algorithms tend to create fewer componentswhich soon turn into one large component.

ORIGINAL_DEGREE performed as well as UPDATED_DEGREE. For k Å 1, it had93–111% of the CMCG calls, with most between 99% and 102%. The average sizes variedfrom 93% to 100.3%. As the density increased, ORIGINAL_DEGREE did slightly betterthan UPDATED_DEGREE. It had slightly fewer CMCG calls, 91% to 97% at k Å 3 and95% to 98% at k Å 5, although it had a slightly larger average CMCG size, 99.6% to 105%at k Å 3 and 99.9% to 103% at k Å 5. UPDATED_DEGREE can efficiently pick leavesoff a treelike sparse graph (k Å 1), but, in denser graphs, updating the degrees seems tomake fewer components than choosing a node with the smallest original degree, whichresulted in more CMCG calls.

We also conducted experiments with three types of nonrandom graphs. These are MILES,RAMAN, and WORDS graphs [9] . Graph MILES consists of 128 North American citiesand distances between them. We generated two graphs of MILES by choosing edges eachof which has a distance not exceeding 450 miles and 900 miles, respectively. When wechose a distance limit less than 450 miles, graph MILES was disconnected. Graph RAMANconsists of approximately q 3 or 0.5 q 3 vertices, each of which has degree p / 1, where pand q are two distinct prime numbers. The RAMAN graph is notable for having large girth1

1 The girth of a graph is the length of its smallest cycle.

8m28 998/ 8M28$$0998 10-06-98 14:05:51 nra W: Nav Res


Table 3. Experimental results with three ordering algorithms: nonrandom graph MILES.

Updated degree Original degree Random

Distance R n Count Size Count Size Count Size

450 10 128 37 36.2 36 44.5 68 62.520 128 17 63.6 20 69.0 56 72.940 128 10 90.0 13 91.8 47 81.7

900 10 128 38 39.5 38 41.1 71 72.520 128 23 56.1 23 58.8 60 83.340 128 11 88.8 14 81.1 54 89.2

and small diameter, and has important applications in communication networks. We used10 combinations of p and q . The WORDS graph was constructed by randomly choosing aset of words from the set of five-letter English words, where adjacent words differ in onlyone letter. We used 10 sets of 1000 words and 10 sets of 2000 words. MILES and RAMANgraphs are connected, while some WORDS graphs are disconnected.

We applied the above three algorithms to each of the total 93 nonrandom graphs andsummarized the results in Tables 3, 4, and 5, respectively. Results similar to those fromthe random graphs were obtained. UPDATED_DEGREE and ORIGINAL_DEGREE had

Table 4. Experimental results with three ordering algorithms: nonrandom graph RAMAN.

Updated degree Original degree Random

p, q R n Count Size Count Size Count Size

3, 7 10 336 140 224.4 139 226.4 226 171.53, 11 660 272 430.2 270 432.3 418 409.43, 13 1092 475 677.3 475 677.3 780 658.95, 13 91 44 65.2 44 65.2 69 56.05, 7 336 168 230.5 169 226.3 204 228.75, 11 660 366 431.2 366 431.2 462 375.15, 47 1128 590 742.5 594 741.2 754 711.47, 31 496 18 81.6 18 81.6 23 93.47, 47 1128 76 316.9 76 309.1 90 401.63, 7 20 336 127 246.0 128 244.7 216 178.93, 11 660 251 465.1 253 460.3 385 443.43, 13 1092 426 753.7 426 753.7 774 663.95, 13 91 41 69.0 41 69.0 66 57.85, 7 336 160 241.3 157 242.5 199 234.05, 11 660 342 460.5 342 460.5 385 447.65, 47 1128 558 784.4 561 783.9 738 726.67, 31 496 13 106.9 13 106.9 21 100.97, 47 1128 62 384.8 60 387.3 82 439.33, 7 40 336 119 260.6 120 259.2 177 211.03, 11 660 237 491.0 239 485.7 380 448.83, 13 1092 409 783.8 409 783.8 768 668.95, 13 91 38 72.5 38 72.5 51 65.95, 7 336 153 251.2 154 246.6 197 236.15, 11 660 333 472.1 333 472.1 381 452.05, 47 1128 541 808.1 545 806.1 736 728.57, 31 496 9 140.6 9 140.6 17 117.87, 47 1128 47 498.3 49 467.5 77 466.0

8m28 998/ 8M28$$0998 10-06-98 14:05:51 nra W: Nav Res


2–56% as many CMCG calls as enumeration with average 29%. They also had a muchsmaller size of CMCGs, ranging between 17% and 80% with average 57%. These algorithmsoutperformed RANDOM, requiring 20–89% as many CMCG calls as RANDOM withaverage 60%. The size of CMCGs called by them ranged between 49% and 138% of thatcalled by RANDOM with average 100%.

5. MCG WITH EDGE COSTS

We consider a more general variant of MCG which deals with edge costs. Given anundirected graph G Å (V, E) , a weight £i for each vertex i √ V, a nonnegative integer costcij for each edge ( i , j) √ E , and a positive integer R*, the maximum-weight connectedproblem with edge costs (MCGEC) is to find a subgraph Gs Å (Vs , Es) that

maximizes ∑i√Vs

£i

subject to

Gs is connected,

∑(i , j )√Es

cij ° R *.

The set of Es of chosen edges need not be all the edges in the induced subgraph on Vs .This in turn implies that without loss of generality the edges in any solution to this problemform a tree. We define the constrained MCGEC (CMCGEC) as MCGEC which mustinclude one predetermined vertex in the solution.

We can solve MCGEC by transforming it into MCG using the following method. Trans-form graph G into G * by replacing each edge with cost c by a path of c 0 1 zero weightednodes connected with c unweighted edges. Find an optimal solution G *s to MCG with R ÅR * / 1 for this new graph G *. If there is a cycle in G*s , remove one node with weight 0from a cycle. Then the optimal solution Gs to MCGEC is obtained by reverse-transformation(i.e., selecting from G *s the vertices that are in the original graph G , and connecting themwith those edges whose transformed nodes are contained in G *s ) . When G has a total edgecost of C , G * has ÉVÉ / C 0 ÉEÉ vertices. This is because in addition to the originalvertices, each edge in G with cost cij is transformed into cij 0 1 vertices in G * and ( (i , j )√E

(cij 0 1) Å C 0 ÉEÉ.

Table 5. Experimental results with three ordering algorithms: nonrandom graph WORDS.

Updated degree Original degree Random Enumeration

R n Count Size Count Size Count Size Count Size

10 1000 16.2 21.2 16.3 21.1 38.9 21.8 161.1 36.720 6.2 34.1 6.0 34.4 16.0 33.3 108.4 48.040 1.4 43.2 1.6 41.8 4.2 38.4 50.7 69.710 2000 93.6 110.3 93.8 103.0 214.4 212.5 636.9 558.120 57.4 167.6 57.2 157.5 172.9 258.3 578.7 613.840 39.1 235.7 38.8 222.2 151.7 294.6 538.7 657.3

8m28 998/ 8M28$$0998 10-06-98 14:05:51 nra W: Nav Res


Figure 5(a). An example graph G for Algorithm MCGEC.

THEOREM 7: The subgraph Gs found by the above procedure is an optimal solutionto MCGEC.

PROOF: Let Go be an optimal solution to MCGEC. If Go is not a tree, then there existsa tree Got which is also an optimal solution to MCGEC. Let G*o be a graph obtained by thetransformation of Got . G *o has at most R Å R * / 1 nodes. When G*o has less than R nodes,add zero weighted nodes and the associated unweighted edges such that the resulting G*ois connected with R nodes. This is done by partially transforming edges in G . The weightsum of G *o ° that of G *s since G *s is an optimal solution to MCG. The cost of the edges inGs is at most R but its weight sum equals that of G*s . By definition of Go , the weight sumof Go ¢ the weight sum of Gs and the result follows. h

EXAMPLE 5: We use Figure 5(a) to illustrate Algorithm MCGEC. R* is set to 7. Thetransformed graph G * appears in Figure 5(b). An optimal solution G*s to the new MCGwith R Å 8 has V *s Å {5, e , f , 3, d , 2, c , 4} with weight sum Å 14. After reverse-transformation of G *s , the optimal solution Gs to MCGEC has Vs Å {5, 3, 2, 4} and Es Å{(5, 3) , (3, 2) , (2, 4)} with the total edge cost of 6. Note that edge (2, c) in G*s forms apartial edge of edge (2, 3) in Gs and is thrown out during reverse-transformation.

6. CONCLUSIONS

In this paper, we introduced a class of decomposition algorithms for MCG. These algo-rithms decompose MCG into a number of small CMCGs by adding vertices one at a timeand building a partial graph. These algorithms differ in the ordering of adding vertices. Fora decomposition algorithm with a very simple ordering, we presented exact analyses fortwo types of random graphs and showed empirically that one of them requires a factor of1/

√R less computational effort than enumeration. We proved that finding an order that

minimizes the number of CMCGs itself is NP-complete and presented two more sophisti-cated decomposition heuristics, ORIGINAL_DEGREE and UPDATED_DEGREE. For atree, we derived a bound for UPDATED_DEGREE, proving that it solves at most theminimum of 2n / (R / 1) CMCGs or twice the minimum possible number of CMCGs. Fromexperiments with 417 test problems using various random and nonrandom graphs with up

8m28 998/ 8M28$$0998 10-06-98 14:05:51 nra W: Nav Res


Figure 5(b). A transformed example graph G * for Algorithm MCGEC.

to 2000 vertices, we showed that this ordering issue can significantly affect the number ofCMCG calls, consequently computation time to solve MCG. The two algorithms called thenumber of CMCGs consistently far less times than random ordering, RANDOM. Thesealgorithms had 20–93% as many CMCG calls as RANDOM with average 56%. Theyhad just 2–60% as many CMCG calls as enumeration with average 35%. They also had amuch smaller size of CMCGs than enumeration, ranging between 17% and 82% withaverage 62%.

One direction for future research is to investigate a more general problem, the connectedknapsack problem (CKP). In this problem, vertices have costs in addition to weights, andthe goal is to find a connected graph which maximizes the weight sum while having thesum of the vertex costs less than R . Decomposition algorithms similar to ones proposed inthis paper can be applied to CKP in order to reduce computation. For this purpose, we needto define the constrained CKP (CCKP) which includes one predetermined vertex in thesolution, like CMCG for MCG. The solution methods for CCKP are left for future research.

ACKNOWLEDGMENTS

This research is supported in part by a grant from National Science Foundation (GrantNo. DDM-9201954) and a grant from Southern Illinois University at Edwardsville. Theauthors also express gratitude to Dr. Hyun Chan Lee and anonymous referees whose com-ments helped to improve the quality and presentation of this article.

REFERENCES[1] Awerbuch, B., Azar, Y., Blum, A., and Vempala, S., ‘‘Improved Approximation Guarantees

for Minimum-Weight k-Trees and Prize-Collecting Salesman,’’ Proceedings of the 27th AnnualACM Symposium on the Theory of Computing, 1995, pp. 277–283.

8m28 998/ 8M28$$0998 10-06-98 14:05:51 nra W: Nav Res


[2] Blum, A., Ravi, R., and Vempala, S., ‘‘A Constant-Factor Approximation Algorithm for the k-MST Problem,’’ Proceedings of the 28th Annual ACM Symposium on the Theory of Computing,1996, pp. 442–448.

[3] Cormen, T.H., Leiserson, C.E., and Rivest, R.L., Introduction to Algorithms, The MIT Press,Cambridge, MA, 1991.

[4] Garey, M.R., and Johnson, D.S., Computers and Intractability: A Guide to the Theory of NP-Completeness, Freeman, New York, 1979.

[5] Garg, N., ‘‘A 3-Approximation for the Minimum Tree Spanning k Vertices,’’ Proceedings ofthe 37th Annual Symposium on Foundations of Computer Science, 1996, pp. 302–309.

[6] Garg, N., and Hochbaum, D., ‘‘An O( log k) Approximation Algorithm for the k MinimumSpanning Tree Problem in the Plane,’’ Proceedings of the 26th Annual ACM Symposium onthe Theory of Computing, 1994, pp. 432–438.

[7] Goldschmidt, O., and Hochbaum, D., ‘‘k-Edge Subgraph Problems,’’ Discrete Applied Mathe-matics, 74, 159–169 (1997).

[8] Hochbaum, D., ‘‘Why Should Biconnected Components be Identified First,’’ Discrete AppliedMathematics, 42, 203–210 (1993).

[9] Knuth, D.E., The Stanford Graphbase: A Platform for Combinatorial Computing, AddisonWesley, New York, 1993.

[10] Kortsarz, G., and Peleg, D., ‘‘On Choosing a Dense Subgraph,’’ Proceedings of the 34th AnnualSymposium on Foundations of Computer Science, 1993, pp. 692–703.

[11] Lee, H.F., and Dooly, D.R., ‘‘Algorithms for the Constrained Maximum-Weight ConnectedGraph Problem,’’ Naval Research Logistics, 43, 985–1008 (1996).

[12] Lee, H.F., and Dooly, D.R., ‘‘Heuristic Algorithms for the Fiber-Optic Network ExpansionProblem,’’ Telecommunication Systems, 7, 355–378 (1997).

[13] Palmer, E.M., Graphical Evolution: An Introduction to the Theory of Random Graphs, Wiley,New York, 1985.

[14] Ravi, R., Sundaram, R., Marathe, M.V., Rosenkrantz, D.J., and Ravi, S.S., ‘‘Spanning TreesShort and Small,’’ Proceedings of the 5th Annual ACM-SIAM Symposium on Discrete Algo-rithms, 1994, pp. 546–555.

[15] Ross, S.M., Introduction to Probability Models (2nd ed.) , Academic, New York, 1980.[16] Tarjan, R.E., ‘‘Efficiency of a Good But Not Linear Set Union Algorithm,’’ Journal of the

ACM, 22(2) , 215–225 (1975).[17] Wormald, N.C., ‘‘Some Problems in the Enumeration of Labelled Graphs,’’ Ph.D. Dissertation,

University of Newcastle, N.S.W., Australia.

8m28 998/ 8M28$$0998 10-06-98 14:05:51 nra W: Nav Res

Documents

Decomposition algorithms for the maximum-weight connected graph problem