2009 macambira.maculan

A Column Generation Approach for SONETRing Assignment

Elder M. Macambira, Nelson MaculanUniversidade Federal do Rio de Janeiro, Programa de Engenharia de Sistemas e Computação, COPPE,Caixa Postal 68511, 21941-972, Rio de Janeiro, RJ, Brazil

Cid C. de SouzaUniversidade Estadual de Campinas, Instituto de Computação, Caixa Postal 6176, 13084-971, Campinas,SP, Brazil

In this article we consider the SONET ring assignmentproblem (SRAP) presented in [7]. The authors pointed outthe inadequacy of solving SRAP instances using theirinteger programming formulation and commercial lin-ear programming solvers. Similar experiences with IPmodels for SRAP are reported in [1]. In this article wereformulate SRAP as a set partitioning model with anadditional knapsack constraint. This new formulationhas an exponential number of columns and, to solve it,we implemented a branch-and-price/column generationalgorithm. Extensive computational experiments showedthat the new algorithm is orders of magnitude faster thanstandard branch-and-bound codes running on compactIP models introduced earlier. Instances taken from [1,7],which could not be solved there in hours of computa-tion were solved here to optimality in just a few seconds.© 2006 Wiley Periodicals, Inc. NETWORKS, Vol. 47(3), 157–1712006

Keywords: telecommunication network design; SONET ring;integer programming; column generation; branch-and-price algo-rithm

1. INTRODUCTION

Consider the following graph optimization problem. Weare given an undirected graph G = (V , E), with |V | = n and

Received August 2004; accepted November 2005Correspondence to: C.C. de Souza; e-mail: [email protected] grant sponsor: CNPq; Contract grant number: 146245/1999-7Contract grant sponsor: FAPERJ; Contract grant number: E-26/152.603/2001 (to E.m.m.)Contract grant sponsor: FAPESP; Contract grant number: 01/14205–6 (toc.c.ds.)Contract grant sponsor: CAPES; Contract grant number: BEX 04444/02–2Contract grant sponsor: CNPq; Contract grant number: 302588/02–7 (toc.c.ds.)Contract grant sponsor: Pronex; Contract grant number: 664107/97–4 (toc.c.ds.)DOI 10.1002/net.20102Published online in Wiley InterScience (www.interscience.wiley.com).© 2006 Wiley Periodicals, Inc.

|E| = m, and a positive integer B. Associated with each edge(u, v) in E is a nonnegative integer duv. A feasible solutionof the problem is a partition of the vertices in G into setsV1, V2, . . . , Vk such that:

∑(u,v)∈G[Vj] ∪ δ(Vj)

duv ≤ B for all j ∈ {1, . . . , k} and (i)∑kj=1

∑(u,v)∈δ(Vj)

duv ≤ B, (ii)

where G[Vj] is the graph induced by Vj in G and δ(Vj) isthe set of edges with exactly one extremity in Vj. The goalis to find a feasible solution that minimizes the size of thepartition, that is, the value of k.

Notice that a trivial necessary condition for the feasibilityof an instance of this problem requires that

∑v|(u,v)∈E duv ≤ B

for each vertex u in V . Moreover, for any feasible instance,there can be no optimal solution in which two subsets of thepartition are composed of singletons. This is because the twoisolated vertices can be grouped together because, otherwise,condition (ii) would not hold for any solution. Thus, a simpleupper bound for the optimal value is given by � n

2�.This graph problem is also known as the SONET (or SDH)

ring assignment problem, or SRAP for short. The SRAP wasinvestigated recently by Goldschmidt et al. [7]. In their articlethe authors motivated the study of the problem by showingits relevance to the design of fiber-optic telecommunicationnetworks using the SONET (Synchronous Optical NETwork)or SDH (Synchronous Digital Hierarchy) technology. In thiscontext, the vertices of graph G are associated with client siteswhile the edges are associated with existing traffic demandbetween pairs of clients. The edge weights duv measure theactual demand for communication among clients. Given afeasible solution to the graph problem stated above, the ver-tices in each subset of the partition form a local ring or simplya ring. Due to physical limitations on the equipment used inbuilding the network, the total demand in each ring must notexceed a constant B (any ring satisfying this property is saidto be a feasible ring). Moreover, the total demand betweenclients in different rings is handled by an additional ring called

NETWORKS—2006—DOI 10.1002/net

the federal ring. The connection of a local ring to the federalring is made possible through a device known as a digitalcrossconnect (DCS). Because the capacity of the federal ringis also bounded by B, the sum of the weights of the edgesin the multicut corresponding to any feasible solution cannotexceed that amount. Finally, because the DCSs are by far themost expensive equipment needed to implement a network,a basic problem in the design of low-cost SONET networksasks for a solution that minimizes the number of local rings.One can easily check that the graph problem discussed at thebeginning of this section correctly models the latter problem.

We refer to [7] for a more detailed discussion of the archi-tecture of SONET networks and a review of the literatureon the SRAP. In their work the authors proved that SRAPis NP-hard. They also introduced an integer programmingformulation for the problem and propose heuristics and exactmethods to solve it. Another recent work on heuristics forSRAP can be found in [1] where tabu and scatter searchmeta-heuristics are proposed.

This article focuses on the solution of SRAP via integerprogramming techniques. Our motivation comes from a com-ment of Goldschmidt et al. in [7] about their IP formulationand which is reproduced below:

“Our results indicate that using this formulation in con-junction with a commercial ILP solver (i.e., CPLEX) isnot a practical approach for solving SRAP.”

The authors also reported that the IP approach is not wellsuited to deal with infeasible instances. Proving infeasibilityis of practical importance for network designers. However,detecting infeasibility is at least as hard as solving the opti-mization problem. This is because any polynomial–timealgorithm for the decision version of SRAP can be combinedwith a simple binary search routine to solve the optimizationversion in polynomial time.

In our work we introduce different IP formulations forSRAP designed to overcome these drawbacks. Our majorresult is a set partitioning type model having an extra knap-sack constraint. This model can be efficiently solved by acolumn generation/branch-and-price type algorithm that wepropose. Conclusions of this work are supported by extensiveexperimentation.

The article is organized as follows. The next section dis-cusses several different IP formulations for SRAP includingthe original formulation from [7] and the set partitioningmodel cited above. Section 3 introduces the main ingre-dients of our branch-and-price algorithm. In Section 4 wedescribe our computational experiments and analyze theresults. Finally, in Section 5 we draw some conclusionsand discuss future directions. Appendix 5 describes a sim-ple heuristic based on the GRASP paradigm (see [6]), whichcomputes initial primal bounds in our tests.

2. INTEGER PROGRAMMING MODELS FOR SRAP

This section describes alternative IP formulations forSRAP. Experiments with these formulations are reported in

the forthcoming sections. From now on, the parameters n andm are used to denote the number of vertices and edges in G,respectively, while the set {1, . . . , n} is represented by N .

2.1. The IP Model from [7]

In [7], the authors introduce an IP formulation for SRAP.It has four groups of binary variables, namely y, x, p, andz. In the first one, there are n variables each representing apossible local ring to be opened in a feasible solution (a ringis said to be open if there is at least one vertex assigned toit). Thus, the variable yi is one if and only if the ith ring isopened. In the second group, there is a variable xui for eachu ∈ V and i ∈ N . The value of xui is one if and only if vertexu is assigned to ring i. For every edge (u, v) in E, with u < v,and every i ∈ N , puvi is one if and only if both vertices uand v are assigned to ring i. This third group of variableshas mn elements. Finally, in the fourth group, we have 2mnz variables. Each z variable is indexed by three elements, thefirst two taken from V × V \ {(u, u) | u ∈ V} and the lastone from N . The variable zuvi is then defined to be one if andonly if u is in ring i while v is not. A possible formulation forSRAP with these variables is given below.

(GM) minn∑

i=1

yi (1)

s.t.∑

(u,v)∈E

duvpuvi +∑u∈V

∑v>u|(u,v)∈E

duvzuvi ≤ B,

∀i ∈ N , (2)

n∑i=1

∑u∈V

∑v>u|(u,v)∈E

duvzuvi ≤ B, (3)

n∑i=1

xui = 1, ∀u ∈ V , (4)

xui − yi ≤ 0, ∀u ∈ V , ∀i ∈ N , (5)

xui + xvi − puvi ≤ 1, ∀(u, v) ∈ E, ∀i ∈ N , (6)

xui − xvi − zuvi ≤ 0, ∀u ∈ V , ∀(u, v) ∈ E, ∀i ∈ N , (7)

xui ∈ {0, 1}, ∀u ∈ V , ∀i ∈ N , (8)

yi ∈ {0, 1}, ∀i ∈ N , (9)

puvi ∈ {0, 1}, ∀(u, v) ∈ E, ∀i ∈ N , (10)

zuvi ∈ {0, 1}, ∀u ∈ V , ∀(u, v) ∈ E, ∀i ∈ N . (11)

Let us briefly examine the constraints in formulation (GM).Constraints (2) and (3) limit the capacities of the local and fed-eral rings. Constraints (4) ensure that every vertex is assignedto a ring. Constraints (5) ensure that a ring is open whenever avertex is assigned to it. For a proper triple (u, v, i), constraint(6) forces puvi to one if both vertices u and v are assignedto ring i while constraint (7) forces zuvi to one if vertex u isassigned to ring i and v is not assigned to that ring.

The mindful reader has certainly noticed that Equations(6) ((7)) are not enough to express the intended relationship

158 NETWORKS—2006—DOI 10.1002/net

between the x and p (z) variables. However, as observed byGoldschmidt et al. [7], given a proper triple (u, v, i) and afeasible solution to (GM) if puvi = 1 and either xui = 0or xvi = 0, another feasible solution with the same cost isobtained by simply setting puvi to zero. An analogous reason-ing applies if zuvi = 1 and either xui = 0 or xvi = 1. Therefore,we can drop from the SRAP formulation the constraints thatforce the p or z variables to zero.

2.2. The Packing Model

Goldschmidt et al. [7] observed in their article that formu-lation (GM) is not suitable for identifying SRAP instanceswhich are infeasible. A possible way to overcome this dis-advantage is to relax the previous model. By doing so, weincrease the set of feasible solutions of the mathematicalformulation. However, these additional solutions have nophysical counterparts and, therefore, cannot be implemented.This is useful provided that the relaxation model becomeseasier to solve than the original one.

Before we continue, we observe that in the remainder ofthis text, the term feasible is used to refer to instances thathave at least one solution that can be physically implemented.

To obtain one alternative relaxation for (GM), we start byreplacing constraints (4) by constraints of the form

n∑i=1

xui ≤ 1. (12)

However, by doing that we also have to change the objectivefunction so that it favors the feasible solutions that are actualpartitions of the vertex set if they exist. This technique isnot a novelty in the solution of hard combinatorial problems.Examples of its application can be found for the general-ized assignment problem (see [12]) or the traveling salesmanproblem (see [8]). The new objective function is given by

max

{∑u∈V

n∑i=1

αxui −n∑

i=1

yi

}. (13)

If the constant α representing the vertex assignment costsis suitably chosen, any solution corresponding to a vertexpartition has a larger objective value than a pure packingsolution where one of the vertices remains unassigned. It isan easy task to check that α = n fulfills this property. This isthe value of α used in our computations.

In his doctoral thesis Macambira [10] conducted a polyhe-dral investigation of the polytope Q given by the convex hullof feasible solutions of the IP model with the replacementsdiscussed above. One of the results presented there that isrelevant to our work refers to the lifting of the inequalities(6). In fact, it is not difficult to see that one such constraint,defined for a proper triple (u, v, i), is satisfied at equality onlyif ring i is open or, in other words, only if yi = 1. A simple0-1 lifting of the yi variable (cf., [13] for an explanation of0-1 liftings) leads to the stronger inequality

xui + xvi − puvi − yi ≤ 0. (14)

Macambira showed that the polytope Q is full-dimensionalwhenever n ≥ 2 and de ≤ B for all e ∈ E. Moreover, underthe same assumptions, he also proved that constraints (5), (7),(12), and (14) are all facet defining for Q.

In the remainder of the text, we shall denote by (PM) themodel composed of constraints (2), (3), (12), (5), (14), (7),the integrality constraints (8)–(11), and the objective func-tion (13).

2.3. The Packing Model with Less Symmetry

Models (GM) and (PM) seen before present a high level ofsymmetry in the sense that a feasible solution with r rings has(n

r

)r! integer representations in these formulations, because

the rings are indistinguishable. It is well known that the pres-ence of symmetry in the model spoils the performance ofenumeration algorithms available for integer programming.Other studies about symmetry on IP models for combinatorialoptimization problems can be found in [9, 15].

A simple way to reduce the symmetry in model (PM) isto add the constraints

y1 = 1, x11 = 1 and yi ≤ yi−1, ∀i ∈ N (15)

Obviously, these inequalities are not enough to com-pletely eliminate symmetry. Nevertheless, as we shall seein Section 4, they are very helpful in practice. Other inequal-ities that we have tried, such as those that force the numberof vertices to decrease as ring indexes increase, did not workas well as the inequalities in (15). A possible explanation forthe success of these inequalities is that they do not increasethe density of the LP constraint matrix, which is known toharm the efficiency of the solvers that compute the linearrelaxations.

We call (SM) the new model obtained by adding to (PM)

the constraints (15).

2.4. The Compact Model

Next we derive a new model for SRAP based on a slightlydifferent set of variables. The purpose is to reduce the numberof variables while keeping the same number of constraints.We hope that by doing so, we end up with a model which iseasier to compute.

To describe this alternative formulation, consider a feasi-ble solution for SRAPwhere the vertices of V are partitionedinto sets V1, . . . , V�. For every j ∈ {1, . . . , �}, the internaland external demands of ring j are, respectively, Dj and Wj,where

Dj =∑u∈Vj

∑v∈Vju<v

duv, (16)

Wj =∑u∈Vj

∑v/∈Vj

duv. (17)

NETWORKS—2006—DOI 10.1002/net 159

Let us denote the total demand by D and the total demand ofring j by dj, i.e.,

D =∑

(u,v)∈Eu<v

duv, (18)

dj = Dj + Wj. (19)

According to those definitions, the demand flowing throughthe federal ring is computed as

�D = D −�∑

j=1

Dj, (20)

and we have that

2 × �D =�∑

j=1

Wj. (21)

Finally, the capacity constraint on the federal ring impliesthat �D ≤ B and, thus,

D + �D ≤ D + B(20)=⇒ �D + �D +

�∑j=1

Dj ≤ D + B

(21)=⇒�∑

j=1

Wj +�∑

j=1

Dj ≤ D + B. (22)

Thus, Equation (22) gives us another way to express thecapacity constraint for the federal ring. It also suggests thatwe can define new binary variables for the edges in G. For all(u, v) in E, u < v, and every i ∈ N , fuvi is set to zero if neithervertex u nor vertex v is assigned to ring i. In other words, fora fixed ring i, the edges with fuvi = 1 are those which areinternal to ring i or link vertices of ring i to vertices of someother ring.

With the variables x and y defined as before, the new IPformulation for SRAP reads

(CM) maxn∑

i=1

∑u∈V

αxui −n∑

i=1

yi (13)

s.t.∑

(u,v)∈E

duvfuvi ≤ B, ∀i ∈ N , (23)

n∑i=1

∑(u,v)∈E

duvfuvi ≤ D + B, (24)

n∑i=1

xui ≤ 1, ∀u ∈ V , (12)

xui − yi ≤ 0, ∀u ∈ V , i ∈ N , (5)

fuvi − xui ≥ 0, ∀(u, v) ∈ E, ∀i ∈ N , (25)

fuvi − xvi ≥ 0, ∀(u, v) ∈ E, ∀i ∈ N , (26)

fuvi − xui − xvi ≤ 0, ∀(u, v) ∈ E, (27)

yi − yi−1 ≤ 0, ∀i ∈ {2, . . . , n}, (15)

xui ∈ {0, 1}, ∀u ∈ V , ∀i ∈ N , (8)

yi ∈ {0, 1}, ∀i ∈ N , (9)

fuvi ∈ {0, 1}, ∀(u, v) ∈ E, ∀i ∈ N . (28)

Let us briefly discuss the model. The objective function is thesame as that for the (PM) and (SM) models and, as discussedearlier, if α is taken to be n, every partition, if there is one,has a more attractive cost than any packing of the vertex set.Constraints (23) and (24) refer to the capacity limitations oflocal and federal rings, respectively. Constraints (25)–(27)ensure the correct relationship between the f and x variables.Finally, constraint (15) is added to the model because, as forthe (PM) model, the reduction in symmetry is beneficial forcomputational purposes.

It should be noticed that, in the formulations presented sofar, an upper bound on the number of rings can be used toreduce the size of the models. If no better bound is available, anatural way of doing that is by decreasing the number of ringvariables to � n

2�. This issue is further discussed in Section 4.

2.5. The Set Partitioning/Knapsack Model

Several important problems in combinatorial optimiza-tion can be modeled as a set partitioning problem (cf., [2]).Usually, the number of variables in those set partitioningformulations is huge, typically exponential in the instancesize. A successful technique is then to solve these models viacolumn generation methods and branch-and-price algorithms(see [3]). The use of column generation is particularly attrac-tive in set partitioning problems where the subsets of the parti-tion are indistinguishable, as is the case forSRAP, because themodel is not affected by symmetry and often produces excel-lent dual bounds. These features motivated us to apply a setpartitioning formulation and column generation techniquesfor SRAP. However, as we show below, the model is not apure set partitioning problem for it has a knapsack-type con-straint which is necessary to model the federal ring capacity.It is worth noting that a similar approach is used in [16] for anedge-partition version of SRAP leading to very good results.

Suppose we define a variable λj for each subset Vj of Vwhich is feasible, i.e., Dj + Wj ≤ B where Dj and Wj aredefined as in (16) and (17), respectively. Moreover, for everyu ∈ V , let auj be one if vertex u is in Vj and zero otherwise.Thus, if � is the number of feasible subsets of V , SRAP canbe formulated by a master problem of the form

(SP) min�∑

j=1

λj (29)

s.t.�∑

j=1

aujλj = 1, ∀u ∈ V , (30)

�∑j=1

djλj ≤ D + B, (31)

λj ∈ {0, 1}, ∀j ∈ {1, . . . , �}. (32)


Constraints (30) guarantee that every vertex belongs to oneof the subsets taken in the solution. Constraint (31) boundsthe demand on the federal ring and can be deduced from (22).

Because � grows exponentially with n, a column gen-eration technique is appropriate. The slave subproblem isobtained as follows. Suppose that the reduced master prob-lem has been solved. Let µu be the dual variable associatedwith constraint (30) written for vertex u, and let π be thedual variable associated with the knapsack constraint in (31).Therefore, the reduced cost of a feasible set Vj is given by

c̄j = 1 −∑u∈Vj

µu − πdj. (33)

Because the master is a minimization problem, we want tominimize the reduced cost among all feasible sets Vj. Thelinear relaxation is solved if this minimum is nonnegative.

We now give an integer programming formulation for thesubproblem. The solution of the subproblem is a feasible sub-set V ′ of V . We start by defining two sets of binary variables.A variable xu is defined for all vertices in V and it takes thevalue one if and only if u is in V ′. A variable fuv is definedfor every edge (u, v) in E and it is set to one if and only ifu ∈ V or v ∈ V . With those variables, the constraints in theformulation of the subproblem are simply those from model(CM) corresponding to a fixed index i in N . Therefore, thesubproblem is given by

(SSP) max∑u∈V

µuxu − π∑

(u,v)∈E

duvfuv (34)

s.t.∑

(u,v)∈E

duvfuv ≤ B, (35)

fuv − xu ≥ 0, ∀(u, v) ∈ E, (36)

fuv − xv ≥ 0, ∀(u, v) ∈ E, (37)

fuv − xu − xv ≤ 0, ∀(u, v) ∈ E, (38)

xu ∈ {0, 1}, ∀u ∈ V , (39)

fuv ∈ {0, 1}, ∀(u, v) ∈ E. (40)

Although in our computational tests we solved (SSP) bypure branch-and-bound, we have also conducted a polyhe-dral study for (SSP). In principle, the results we found couldbe used to implement a branch-and-cut approach for (SSP).However, preliminary experiments completely discouragedus from pursuing this idea. Despite that, the polytope P′ asso-ciated with the convex hull of feasible solutions of (SSP)

shares some nice properties with other polytopes studiedearlier in the literature. This relationship is discussed in [11].

2.6. Model Sizes

To conclude this section we summarize in Table 1 thetotal number of variables and constraints in the main modelspresented so far. Clearly, they all have a number of con-straints that is polynomial in the size of the input graph. Asfor the number of variables, the same holds for all models butmodel (SP).

TABLE 1. Model sizes.

Model # variables # constraints

(GM) n2 + n + 3mn n2 + 2n + 3mn + 1(CM) n2 + n + mn n2 + 3n + 3mn + 1(SSP) n + m 1 + 3m(SP) exponential n + 1

3. A BRANCH-AND-PRICE ALGORITHMFOR SRAP

In this section we discuss the essential ingredients of thebranch-and-price algorithm that we implemented to solve for-mulation (SP). The design of our code was strongly drivenby [3] and [18]. We restrict our discussion to the strategiclevel of the algorithm; namely, we describe our choices for theset of initial columns, the selection of nodes to explore, thebranching scheme, the detection of a tailing off effect, andthe inclusion (or not) of multiple generated columns. Thesechoices are detailed below.

3.1. The Initial Set of Columns

To apply column generation for model (SP), we musthave an initial set of columns that form a basis for the lin-ear relaxation. However, it is not easy in general to findsuch a set. Instead, we decide to add columns correspond-ing to artificial variables, each with a high cost, with theaim that they will not appear in an optimal solution. If anyof these columns is present in the optimal integer solutionthen we conclude that the SRAP instance is infeasible. Sucha set of initial columns can be constructed in the followingmanner.

For every u ∈ V , construct a column of the form(en

u0

)where en

u is the unit vector of Rn with one in component u

and zero elsewhere. Notice that this column does not actuallycorrespond to an assignment where vertex u is the only vertexin a ring. If it did, the last component of the vector, that is, theone corresponding to the constraint (31), should take value∑

(u,v)∈E duv. Hence, this artificial column receives a cost ofn, which is large enough so that, if it is part of an integeroptimal solution, this solution has cost larger than any feasiblepartition of the vertices. Now, the n columns built in that way,together with the column corresponding to the slack variableof constraint (31), form a basis.

Besides those columns, we also populate the initial matrixof the reduced master with randomly generated columns.This is done until 5n + 1 distinct columns have beenadded, including the artificial ones. The algorithm is givenin Figure 1. Notice that, in principle, it may run into anendless loop. However, this has never happened in ourexperiments where, typically, a few seconds of computa-tion proved to be enough to generate the 5n + 1 distinctcolumns. If this was not the case, the loop could be easilyavoided by specifying some limit on the execution time ofthe algorithm.


procedure Generate-initial-columns;1. A ← ∅;2. while |A| < 4n + 1 do3. generate a random number t in N ;4. randomly select t different vertices in V ;

Let S be the set formed by those vertices;5. D(S) ← ∑

(u,v)∈G[S] duv;6. W(S) ← ∑

(u,v)∈δ(S) duv;7. while D(S) + W(S) > B do8. select randomly a vertex u in S;9. remove u from S;10. end while11. Let (a, D(S) + W(S)) be the column corresponding to S;12. if a ∈ A, A ← A ∪ {a};13. end whileend Generate-initial-columns.

FIG. 1. Algorithm for generating a set of initial columns.

3.2. Node Selection and Branching Rules

In our implementation the next to node to explore duringthe enumeration procedure is selected as the one with the bestdual bound. The branching rule adopted is the one proposedby Ryan and Foster [14] for set partitioning problems. Thisrule is based on the following proposition.

Proposition 3.1. [14] If A is a 0–1 matrix and λ∗ is afractional solution of the system Aλ = 1, then there exist twoequations u and v in that system such that

0 <∑

k|auk=avk=1

λk < 1. (41)

From Proposition 3.1, Ryan and Foster suggested addingthe following branching constraints∑

k|auk=avk=1

λk = 0 (42)

and ∑k|auk=avk=1

λk = 1. (43)

In the case of SRAP, the constraints above give rise totwo auxiliary subproblems. In the first one, vertices u and vmust necessarily be in different rings, while in the second onethey must be assigned to the same ring. It is well known thatthis branching rule leads to more balanced enumeration treeswhich, in turn, tend to improve the performance of branch-and-bound algorithms.

3.3. Primal Bounding

Our branch-and-price algorithm always starts by runningthe GRASP heuristic described in the appendix. If the heuris-tic is successful, the incumbent value is initialized with thecost of the feasible solution produced by GRASP. Otherwise,the incumbent is initialized as � n

2�+1 because, as mentioned

earlier, any feasible solution must have at most this numberof rings.

Primal bounds are also computed at the nodes of the enu-meration tree. This is done after the solution of each reducedmaster problem. First, a maximal packing of feasible ringsis constructed considering the rings associated with columnsof the current master problem. Higher priority is given tocolumns that were generated more recently. If there stillremain unassigned vertices, they are grouped together in anew ring. In general, the solution so obtained is not feasi-ble and is used to start the GRASP heuristic discussed in theappendix. As soon as the heuristic finds a feasible solution,it stops and the value of the primal bound is updated whennecessary. Otherwise, the heuristic fails.

3.4. Tailing Off Detection and MultipleColumn Generation

The solution of the linear relaxation at a node of the enu-meration tree is done via column generation. It may occurthat the value of the linear relaxation remains practicallyunchanged even after several columns have been added tothe reduced master problem. This phenomenon is known astailing off, and impairs the efficiency of the algorithm. Toavoid spending too much time generating useless columnsand solving LPs, we adopt the following policy to detect tail-ing off. If after 50 consecutive computations of the reducedmaster problem the value of the linear relaxation improvedby less than 0.1%, a branching is done at the current node.In this case, a dual bound is obtained using the techniqueintroduced in [5], which is convenient for SRAP because, forunitary costs, the bound can be computed by simply dividingthe optimal value of the reduced master by one minus theoptimal value of the subproblem.

Another important aspect of column generation is howone solves the subproblem. We tested two ways to generatethe columns: one heuristic, and the other exact. The heuris-tic generation was outperformed by the exact one, so weabandoned this alternative. The exact method solves the sub-problem using a standard LP-branch-and-bound code. In thiscase, the IP problem to be solved is composed of the con-straints in the model (SSP) from the previous section and theconstraints required by the branchings that led to the currentnode. Later, in Subsection 4.3, we report the results obtainedwhen comparing the strategy where we add just the columncorresponding to the optimal solution against that where weadd all columns with negative reduced cost that are encoun-tered by the branch-and-bound code during the solution ofthe subproblem.

4. COMPUTATIONAL EXPERIMENTS

In this section we describe our computational experimentswith the different IP models proposed in Section 2. All testswere run on a desktop PC equipped with a 2.4-GHz AMDAthlon XP processor and 1 Gbyte of RAM, and under theLinux operating system. Linear programming relaxations


were solved using XPRESS version 12.05 ([4]), and thebranch-and-price algorithm of Section 3 was implementedvia the XOSL callable library of XPRESS. All runs werelimited to one hour of CPU time.

4.1. Instances

The set of instances is divided into three categories.Instances in category C1 are taken from [7] and corre-spond to instances of type 1 and 2 in that article. Theseare the instances that the authors proved to be feasible forSRAP. We denote by C1a the subset of the instances of C1whose graphs have no more than 25 vertices. Category C2is composed of all instances tested in [1] excluding thosealready in C1. Finally, category C3 includes the instancesin Table 14 of [7], whose feasibility status could not beproved with the algorithms proposed in that paper. Actually,in [7], the authors conjectured that the instances in C3 wereinfeasible.

In total, there are 111 instances in C1, 56 in C1a, 230in C2, and 12 in C3. Within each category, instances aredivided into geometric and random ones and, then, fur-ther divided into those having low and high ring capacities,respectively, 155 and 622 Mbs. These characteristics of aninstance can be deduced from its name. Instance namesalways start with two letters. The first letter is either “g”or “r,” meaning that the instance belongs to the geometricor the random subdivision, respectively. The second letteris either “l” or “h,” depending on whether the ring capacityis 155 or 622 Mbs, respectively. For more details on howthose instances were generated and their properties, we referthe interested reader to the original articles where they wereintroduced.

4.2. Comparison between Models (GM), (PM), (SM),and (CM)

To compare the performance of the models (GM), (PM),(SM), and (CM) discussed in Section 2 we use the instancesin class C1a. Graphs in those instances have no morethan 25 vertices, and our experiments showed that runningXPRESS for larger graphs with the (GM) model was tootime consuming. All models were computed by the standardbranch-and-bound procedure available in XPRESS withoutany special parameter tuning.

The number of rings in all runs reported below wasbounded by the minimum of � n

2� and the value of the fea-sible solution produced by the GRASP heuristic describedin the Appendix. In most cases in class C1a, the GRASPvalue is optimal. We observe that using such values toreduce the model sizes also reduces the advantages of the(PM) and (SM) models over (GM), which becomes thebest among those three options. In fact, the experimentsshowed that the time spent by the branch-and-bound proce-dure increases, sometimes considerably, with the addition ofinequalities to avoid symmetry. But, in earlier experiments,we noticed that weaker bounds tend to change the algorithm’s

TABLE 2. Comparison of (GM) and (CM) models for C1a instances.

Model (GM) Model (CM)

Instance z∗ #nodes z � (%) Time #nodes z � (%) Time

gl_15_1 3 396 3 0.00 1 207 3 0.00 <0gl_15_4 3 132 3 0.00 <0 100 3 0.00 <0gl_15_7 3 1102 3 0.00 6 955 3 0.00 2gl_15_9 3 553 3 0.00 <0 144 3 0.00 <0gl_25_1 4 16828 4 0.00 245 8959 4 0.00 48gl_25_3 3 35602 3 0.00 166 939 3 0.00 2gl_25_4 4 23609 4 0.00 539 2243 4 0.00 15gl_25_7 3 888 3 0.00 3 1535 3 0.00 3gl_25_8 4 32937 4 0.00 429 29103 4 0.00 203gh_15_1 3 576 3 0.00 1 121 3 0.00 <0gh_15_2 3 531 3 0.00 1 164 3 0.00 <0gh_15_3 2 251 2 0.00 <0 21 2 0.00 <0gh_15_6 2 219 2 0.00 <0 23 2 0.00 <0gh_15_7 2 72 2 0.00 <0 41 2 0.00 <0gh_15_8 3 659 3 0.00 2 2836 3 0.00 5gh_15_9 3 466 3 0.00 1 805 3 0.00 1gh_15_1 2 66 2 0.00 <0 21 2 0.00 <0gh_25_1 3 926 3 0.00 4 252 3 0.00 <0gh_25_2 2 1071 2 0.00 3 137 2 0.00 <0gh_25_3 2 1102 2 0.00 1 151 2 0.00 <0gh_25_4 3 3207 3 0.00 7 491 3 0.00 1gh_25_7 4 73468 4 0.00 2977 102602 4 0.00 1115gh_25_8 3 2736 3 0.00 16 261 3 0.00 <0gh_25_9 3 2124 3 0.00 14 241 3 0.00 <0rl_15_1 3 356 3 0.00 <0 129 3 0.00 <0rl_15_3 2 27 2 0.00 <0 20 2 0.00 <0rl_15_4 3 219 3 0.00 <0 411 3 0.00 <0rl_15_6 3 310 3 0.00 <0 149 3 0.00 <0

behavior the other way around, that is, (PM) and (SM) oftenoutperform (GM).

The direct comparison between (GM) and (CM) highlyfavors the latter, even when tight upper bounds are avail-able for the optimum which, as mentioned above, greatlyimproves (GM)’s performance. This can be seen by inspect-ing the results depicted in Tables 2 and 3. In these tables,the first column contains the instance names and column z∗displays the optimal value. For each model there are fouradditional columns: “#nodes” being the number of nodesexplored in the enumeration tree, “z” being the best dualbound reached during the computation, “�” representing therelative gap between the dual bound and the optimal valueand, finally, “time” indicating the CPU time in seconds nec-essary to solve the model or to halt the execution after onehour of computation.

One can see from the results that (CM) solved all but oneinstance in less than an hour, one more than (GM). Amongthe 22 instances solved by both codes in more than a second,the average ratio between the (GM) and (CM) computationtimes indicates that (CM) was 9.69 times faster than (GM).On the other hand, the analogous average ratio shows that(CM) opened 3.98 fewer nodes during the enumeration than(GM). In total, there are 38 instances where at least one ofthe codes spent more than a second, 37 of which were solvedfaster with (CM).


TABLE 3. Comparison of (GM) and (CM) models for C1a instances.

Model (GM) Model (CM)

Instance z∗ #nodes z � (%) Time #nodes z � (%) Time

rl_15_8 3 400 3 0.00 <0 425 3 0.00 <0rl_15_9 3 531 3 0.00 1 233 3 0.00 <0rl_15_1 3 336 3 0.00 1 850 3 0.00 1rl_25_2 3 668 3 0.00 1 478 3 0.00 <0rl_25_4 4 44108 4 0.00 727 26452 4 0.00 128rl_25_5 4 86663 4 0.00 575 39055 4 0.00 142rl_25_6 4 24319 4 0.00 437 15278 4 0.00 87rl_25_7 4 11265 4 0.00 190 4247 4 0.00 22rl_25_8 3 504 3 0.00 1 205 3 0.00 <0rl_25_9 4 72047 4 0.00 988 49226 4 0.00 246rl_25_1 4 17862 4 0.00 216 11119 4 0.00 50rh_15_1 3 636 3 0.00 1 157 3 0.00 <0rh_15_4 2 105 2 0.00 <0 33 2 0.00 <0rh_15_5 3 524 3 0.00 1 133 3 0.00 <0rh_15_6 3 763 3 0.00 1 282 3 0.00 <0rh_15_7 2 114 2 0.00 <0 25 2 0.00 <0rh_15_8 2 601 2 0.00 <0 154 2 0.00 <0rh_15_9 3 610 3 0.00 1 292 3 0.00 <0rh_25_1 3 6748 3 0.00 86 12239 3 0.00 60rh_25_2 3 5844 3 0.00 38 1028 3 0.00 2rh_25_3 3 1960 3 0.00 9 71 3 0.00 <0rh_25_4 3 59529 3 0.00 875 16223 3 0.00 69rh_25_5 4 110400 3.08 23.00 3600 310918 4 0.00 3109rh_25_6 4 17000 2.09 47.75 3600 35000 2 50.00 3600rh_25_7 3 1450 3 0.00 10 414 3 0.00 <0rh_25_8 4 75486 4 0.00 1777 158077 4 0.00 1522rh_25_9 2 71 2 0.00 <0 26 2 0.00 <0rh_25_1 3 5089 3 0.00 15 1174 3 0.00 3

These results show that our model is superior to (GM).Moreover, it is worth mentioning that our preliminary resultsshowed that the superiority of (CM) over (GM) becomes

even more evident when no tight upper bound on the optimalvalue is provided a priori to the models (see [11]).

4.3. Single vs. Multiple Column Generation in theB&P Algorithm

Before comparing the (SP) model with the previousones, we first report our experiments to verify whetherthe generation of multiple columns with negative reducedcost improves the performance of the B&P algorithm. Asmentioned earlier, preliminary results discouraged using theheuristic generation of columns. However, an alternative wayto generate suboptimal columns is to store all those havingnegative reduced costs that are found by the pure branch-and-bound that solves the subproblem. Table 4 presentsthe results obtained by these two strategies for generatingcolumns, namely, the generation of a single or of multiplecolumns per subproblem. In this table, column “#initial”represents the number of columns in the initial reducedmaster problem. For each strategy, there are four columns:“#nodes” being the number of nodes explored in the enu-meration tree, “#sub” being the number of subproblemssolved, “#cols” being the number of columns generated and,finally, “time” signifying the time (in seconds) necessary tosolve that particular instance. We remark that the computa-tion times reported in Table 4 were obtained on a slightlyslower machine than the one used in the other experiments.The 20 instances that took part in this experiment werepicked randomly from classes C1 and C2. For all of them,the multiple column generation strategy results in a fasterB&P algorithm in which fewer subproblems needed to besolved. Thus, we decided to use this strategy in our finalruns.

TABLE 4. Comparison of strategies to generate columns in the B&P algorithm.

One column Multiple columns

Instance #initial #nodes #sub #cols Time #nodes #sub #cols Time

gl_15_1 76 1 22 21 0.72 1 13 24 0.48gl_15_4 76 1 26 25 0.72 1 21 33 0.62gl_15_7 76 1 34 33 1.24 1 13 27 0.45gl_15_9 76 1 34 33 0.98 1 18 35 0.63gl_25_1 126 1 68 67 7.01 1 42 106 4.78gl_25_3 126 1 87 86 4.93 1 54 127 3.33gl_25_4 126 1 95 94 6.09 1 53 102 3.56gl_25_7 126 1 102 101 4.76 1 51 128 3.49gl_25_8 126 1 107 106 8.79 1 46 127 4.17rl_50_1 251 1 255 254 27.33 1 153 519 21.02rl_50_5 251 3 204 203 19.38 3 153 717 17.17rl_50_6 251 1 204 203 17.54 1 153 453 15.75rh_30_1 151 1 153 152 12.56 1 102 284 8.41rh_30_2 151 1 139 138 40.89 1 61 195 23.29rh_30_4 151 1 146 145 23.46 1 68 200 12.81rh_30_6 151 1 141 140 33.31 1 68 192 19.32rh_30_7 151 1 127 126 26.70 1 57 179 13.91rh_30_8 151 1 136 135 22.58 1 56 191 9.95rh_30_9 151 1 131 130 20.31 1 58 189 9.41rh_30_10 151 1 102 101 13.68 1 54 197 10.81


TABLE 5. Comparison between (SP) and (CM) computing times.

Instance CM time (seconds) GM time (seconds) CM/GM

gl_25_1 48.00 3.90 12.31gl_25_3 2.00 2.73 0.73gl_25_4 15.00 3.10 4.84gl_25_7 3.00 2.93 1.02gl_25_8 203.00 3.34 60.78gh_15_8 5.00 1.89 2.65gh_15_9 1.00 1.00 1.00gh_25_4 1.00 3.84 0.26gh_25_7 1115.00 8.35 133.53rl_25_4 128.00 3.66 34.97rl_25_5 142.00 2.19 64.84rl_25_6 87.00 4.61 18.87rl_25_7 22.00 3.39 6.49rl_25_9 246.00 4.48 54.91rl_25_10 50.00 3.82 13.09rh_25_1 60.00 5.68 10.56rh_25_2 2.00 5.76 0.35rh_25_4 69.00 8.96 7.70rh_25_5 3109.00 9.39 331.10rh_25_8 1522.00 8.95 170.06rh_25_10 3.00 6.29 0.48

Average 325.38 4.68 44.31

4.4. Comparison between Models (CM) and (SP)

We are now ready to compare the performance of theB&P algorithm when computing the (SP) model against thatof the standard branch-and-bound algorithm when appliedto (CM), the best formulation to compute SRAP instancesso far. The 21 instances considered in these tests are thoseof C1a that were solved to optimality with both (CM) and(SP) in a second or more. We discard instances with smallerCPU time to reduce the effects of imprecision in the com-putation of this measure. We focus our attention only on theCPU times needed by both algorithms. The results are sum-marized in Table 5. The speedups are measured as the ratiobetween the CPU time of the branch-and-bound algorithmand that of the B&P algorithm. The average speedup attainedis 44 and only in four instances did (CM) run faster than(SP). But, in the latter case, the average speedup is only 2.5.This shows that B&P is by far more efficient than B&B.In fact, the results are so good that one may wonder if thelimitations pointed in [7] relative to the performance of IPmodels and algorithms for SRAP cannot be overcome withthis approach. This possibility is further investigated in thenext subsection.

4.5. Results of the B&P Algorithm forC1 and C2 Instances

We now report on the results obtained by the B&P algo-rithm and the (SP) formulation for the instances in classesC1and C2, except those corresponding to instances gh_50_1from C1 and to instances gl_50_6.8, gl_50_10,gh_50_2.3, gh_50_2.4, gh_50_2.7, gh_50_9.6,rl_50_2.2, rl_50_8.2 and rl_50_8.5 from C2,which are discussed in Subsection 4.7.

These results are displayed in Tables 6–10. The first ofthese tables contains data from C1a instances, the secondcontains data from instances in C1\C1a, and the remainingthree have data fromC2 instances. In these tables the symbols

TABLE 6. Results from B&P algorithm for C1a instances.

Instance #nod #sub #ini #gen zub zr z∗ Time

gl_15_1 1 13 76 24 3 2.83 3 0.43gl_15_4 1 21 76 33 3 2.67 3 0.46gl_15_7(∗) 1 13 76 27 3 3.00 3 0.40gl_15_9 1 18 76 35 3 2.22 3 0.57gl_25_1 1 42 126 106 4 3.39 4 3.90gl_25_3 1 54 126 127 3 2.93 3 2.73gl_25_4 1 53 126 102 4 3.25 4 3.10gl_25_7 1 51 126 128 3 2.56 3 2.93gl_25_8 1 46 126 127 4 3.96 4 3.34gh_15_1 1 23 76 53 3 2.14 3 1.02gh_15_2 1 20 76 33 3 2.33 3 1.67gh_15_3 1 18 76 32 2 1.86 2 0.48gh_15_6 1 26 76 53 2 1.75 2 0.72gh_15_7 1 30 76 46 2 1.50 2 0.51gh_15_8 1 21 76 58 3 2.85 3 1.89gh_15_9 1 18 76 29 3 2.39 3 1.00gh_15_10 1 31 76 55 2 1.59 2 0.65gh_25_1 1 55 126 149 3 2.30 3 4.91gh_25_2 1 77 126 194 3 1.95 2 4.13gh_25_3 1 92 126 226 2 1.95 2 5.74gh_25_4 1 35 126 80 3 2.59 3 3.84gh_25_7 1 47 126 129 4 3.45 4 8.35gh_25_8 1 61 126 156 3 2.56 3 5.90gh_25_9 1 60 126 150 3 2.60 3 5.22rl_15_1 1 21 76 42 3 2.36 3 0.84rl_15_3 1 24 76 44 2 1.73 2 0.53rl_15_4 1 23 76 41 3 2.85 3 1.29rl_15_6 1 24 76 49 3 2.25 3 0.65rl_15_8 1 22 76 39 3 2.50 3 0.90rl_15_9 1 21 76 36 3 2.30 3 0.69rl_15_10 1 20 76 40 3 2.95 3 0.85rl_25_2 1 44 126 126 3 2.84 3 2.67rl_25_4 1 38 126 108 4 3.28 4 3.66rl_25_5 1 40 126 121 4 3.04 4 2.19rl_25_6 1 47 126 121 4 3.31 4 4.61rl_25_7 1 32 126 101 4 3.40 4 3.39rl_25_8 1 47 126 121 3 2.57 3 2.31rl_25_9 1 50 126 138 4 3.34 4 4.48rl_25_10 1 44 126 130 4 3.29 4 3.82rh_15_1 1 22 76 49 3 2.37 3 1.71rh_15_4 1 25 76 48 2 1.65 2 0.80rh_15_5 1 23 76 49 3 2.23 3 1.35rh_15_6 1 19 76 42 3 2.18 3 1.47rh_15_7 1 27 76 49 2 1.74 2 0.98rh_15_8(∗) 1 26 76 47 2 2.00 2 1.49rh_15_9 1 15 76 34 3 2.13 3 0.69rh_25_1 1 44 126 132 3 2.95 3 5.68rh_25_2 1 50 126 154 3 2.25 3 5.76rh_25_3 1 53 126 147 3 2.27 3 5.48rh_25_4 1 40 126 138 3 2.99 3 8.96rh_25_5 1 45 126 148 4 3.29 4 9.39rh_25_6 1 42 126 134 4 2.96 4 7.20rh_25_7 1 70 126 185 3 2.23 3 9.47rh_25_8 1 45 126 139 4 3.11 4 8.95rh_25_9 1 89 126 204 2 1.58 2 4.05rh_25_10 1 64 126 167 3 2.06 3 6.29


TABLE 7. Results from B&P algorithm for C1 \ C1a instances.


gl_30_1 1 71 151 195 4 3.56 4 5.80gl_30_2 1 90 151 205 4 3.43 4 6.55gl_30_3 1 84 151 198 4 3.25 4 7.55gl_30_4 1 81 151 195 4 3.10 4 5.64gl_30_5(∗) 1 109 151 242 3 3.00 3 8.23gl_30_6 1 77 151 182 4 3.13 4 5.94gl_30_7 1 65 151 161 4 3.26 4 8.40gl_30_8 1 68 151 167 4 3.44 4 7.37gl_30_9 1 75 151 186 4 3.15 4 4.79gl_50_1 1 279 251 792 6 4.50 5 80.12gl_50_4 1 160 251 489 6 5.06 6 49.73gl_50_7 1 136 251 414 5 4.42 5 39.10gl_50_8 1 192 251 592 6 4.83 5 65.97gl_50_9 1 369 251 1008 4 3.41 4 61.13gh_30_1 1 87 151 229 3 2.61 3 7.16gh_30_2 1 63 151 161 4 3.25 4 12.91gh_30_3 1 49 151 147 4 3.40 4 8.55gh_30_4 1 116 151 267 3 2.75 3 16.79gh_30_5 1 51 151 143 4 3.30 4 8.56gh_30_9 1 62 151 170 4 3.14 4 8.90gh_30_10 1 111 151 286 3 2.19 3 9.42gh_50_4 1 241 251 685 5 3.91 4 107.16gh_50_5 1 226 251 697 5 4.15 5 75.27gh_50_6 1 200 251 593 5 4.67 5 94.98gh_50_7 1 185 251 602 5 4.33 5 79.59rl_30_1 1 66 151 174 3 2.74 3 4.99rl_30_4 1 69 151 180 4 3.79 4 6.24rl_30_5 1 73 151 201 4 3.06 4 6.29rl_30_7 1 70 151 198 3 2.92 3 6.56rl_30_8 1 62 151 190 4 3.17 4 8.77rl_30_10 1 76 151 215 4 3.50 4 6.97rl_50_1 1 171 251 567 5 4.22 5 32.17rl_50_3 1 170 251 536 5 3.80 4 34.40rl_50_4 1 159 251 528 5 3.83 4 37.37rl_50_5 1 225 251 697 5 3.62 4 43.02rl_50_6 1 302 251 909 4 3.57 4 52.50rl_50_7 1 130 251 439 5 4.35 5 23.33rl_50_10 1 153 251 481 5 3.68 4 25.12rh_30_1 1 102 151 284 3 2.09 3 8.69rh_30_2 1 61 151 195 4 3.12 4 19.54rh_30_3 1 88 151 262 3 2.17 3 7.65rh_30_4 1 68 151 200 3 2.48 3 10.50rh_30_6 1 68 151 192 4 3.38 4 16.33rh_30_7 1 57 151 179 4 3.12 4 11.64rh_30_8 1 56 151 191 3 2.89 3 8.43rh_30_9 1 58 151 189 3 2.74 3 7.88rh_30_10(∗) 1 54 151 197 4 3.00 3 9.15rh_50_1 1 158 251 565 4 3.54 4 79.08rh_50_2 1 209 251 791 4 2.76 3 76.11rh_50_5 1 206 251 672 3 2.59 3 41.73rh_50_6 1 193 251 718 3 2.66 3 55.00rh_50_8 1 192 251 698 4 3.42 4 90.26rh_50_9 1 165 251 605 4 3.17 4 50.41rh_50_10 1 134 251 476 5 3.89 4 58.39

“∗” and “+” are amended to instance names whenever theoptimal solution of the linear relaxation at the root nodeis integral or our GRASP heuristic is unable to produce aninitial feasible solution, respectively. The first column con-tains the instance name and the subsequent columns contain,respectively: the total number of nodes explored, the num-ber of subproblems solved, the number of initial columns,

TABLE 8. Results from B&P algorithm for C2 instances.


gl_15_3.1 1 14 76 33 4 3.28 4 0.36gl_15_3.2 1 12 76 32 4 3.18 4 0.39gl_15_3.3 1 13 76 30 4 3.25 4 0.34gl_15_3.4 1 29 76 49 4 3.19 4 1.01gl_15_3.5 1 15 76 27 4 3.20 4 0.39gl_15_3.6 1 12 76 32 4 3.18 4 0.39gl_15_3.7 1 29 76 49 4 3.19 4 1.02gl_15_3.8 1 13 76 30 4 3.25 4 0.33gl_15_3.9 1 15 76 27 4 3.20 4 0.39gl_15_3.10 1 14 76 33 4 3.29 4 0.37gl_15_6.1(∗) 1 20 76 39 3 3.00 3 0.94gl_15_6.2(∗) 1 23 76 50 3 3.00 3 1.00gl_15_6.3(∗) 1 19 76 38 3 3.00 3 0.76gl_15_6.4(∗) 1 20 76 51 3 3.00 3 0.75gl_15_6.5 1 21 76 42 3 2.98 3 0.79gl_15_6.6 1 21 76 49 3 2.94 3 0.86gl_15_6.7(∗) 1 25 76 52 3 3.00 3 1.03gl_15_6.8(∗) 1 11 76 29 3 3.00 3 0.39gl_15_6.9(∗) 1 12 76 32 3 3.00 3 0.34gl_15_6.10(∗) 1 12 76 24 3 3.00 3 0.45gl_25_9.1 1 40 126 120 4 3.61 4 1.74gl_25_9.2 1 43 126 107 4 3.38 4 2.35gl_25_9.3 1 54 126 154 4 3.42 4 3.50gl_25_9.4 1 28 126 92 4 3.42 4 1.55gl_25_9.5 1 45 126 116 4 3.33 4 2.78gl_25_9.6 1 35 126 120 4 3.36 4 2.27gl_25_9.7 1 42 126 130 4 3.97 4 1.50gl_25_9.8 1 48 126 133 4 3.37 4 2.58gl_25_9.9 1 49 126 133 4 3.33 4 2.62gl_25_9.10 1 40 126 115 4 3.33 4 1.89gl_25_10.1 1 60 126 118 5 4.29 5 5.33gl_25_10.2 1 63 126 126 5 4.28 5 4.69gl_25_10.3 1 65 126 141 5 4.31 5 5.59gl_25_10.4 1 63 126 126 5 4.29 5 4.68gl_25_10.5 1 59 126 144 5 4.32 5 4.42gl_25_10.6 1 39 126 90 5 4.27 5 2.95gl_25_10.7 1 52 126 119 5 4.90 5 2.38gl_25_10.8 1 46 126 96 5 4.29 5 2.99gl_25_10.9 1 62 126 143 5 4.29 5 4.47gl_25_10.10 1 65 126 141 5 4.31 5 5.59gl_30_10.1 1 53 151 129 5 4.74 5 4.26gl_30_10.2 1 82 151 217 6 4.59 5 7.39gl_30_10.3 1 69 151 178 5 4.49 5 6.17gl_30_10.4 1 68 151 159 5 4.61 5 3.38gl_30_10.5 1 68 151 189 6 4.47 5 6.90gl_30_10.6 1 59 151 172 5 4.49 5 5.06gl_30_10.7 1 60 151 153 5 4.50 5 3.92gl_30_10.8 1 81 151 200 5 4.48 5 8.75gl_30_10.9 1 80 151 194 5 4.48 5 12.48gl_30_10.10 1 55 151 137 5 4.56 5 3.58gl_50_6.1 1 204 251 584 8 5.69 6 30.29gl_50_6.2(+) 1 180 251 571 10 5.89 6 27.17gl_50_6.3 3 213 251 636 7 5.59 6 52.02gl_50_6.4(+) 1 271 251 818 10 5.61 6 63.61gl_50_6.5(+) 3 192 251 548 10 5.69 6 31.23gl_50_6.6 1 236 251 691 7 5.49 6 185.56gl_50_6.7(+) 1 203 251 618 10 5.69 6 35.68gl_50_6.9(+) 3 229 251 705 10 5.50 6 100.48gl_50_6.10(+) 21 264 251 674 10 5.55 6 290.44gl_50_10.1 7 190 251 561 6 5.00 5 38.83gl_50_10.2(∗) 1 313 251 919 6 5.00 5 42.32gl_50_10.3 59 816 251 1997 7 5.21 6 160.24gl_50_10.4 1 309 251 846 6 5.00 5 52.79gl_50_10.5 1 246 251 704 7 4.96 5 65.20gl_50_10.6(∗) 1 271 251 690 7 5.00 5 30.44gl_50_10.8 1 180 251 545 6 4.99 5 48.49gl_50_10.9 1 321 251 878 7 5.06 6 65.81gl_50_10.10(+) 13 279 251 775 8 5.25 6 39.67




gh_25_5.1 1 50 126 127 4 3.42 4 6.42gh_25_5.2 1 61 126 206 4 3.47 4 6.79gh_25_5.3 1 55 126 158 4 3.39 4 6.32gh_25_5.4 1 54 126 177 4 3.43 4 5.69gh_25_5.5 1 42 126 148 4 3.44 4 5.51gh_25_5.6 1 38 126 99 4 3.36 4 4.00gh_25_5.7 1 63 126 175 4 3.38 4 7.21gh_25_5.8 1 52 126 156 4 3.40 4 6.16gh_25_5.9 1 46 126 143 4 3.47 4 3.85gh_25_5.10 1 50 126 160 4 3.39 4 7.61gh_30_8.1 1 86 151 233 4 3.61 4 6.70gh_30_8.2 3 76 151 240 5 3.54 4 7.91gh_30_8.3 1 81 151 264 4 3.58 4 6.29gh_30_8.4 1 68 151 240 4 3.55 4 8.78gh_30_8.5 1 82 151 254 4 3.57 4 7.81gh_30_8.6 1 61 151 199 4 3.52 4 7.33gh_30_8.7 1 52 151 188 4 3.54 4 6.80gh_30_8.8 1 72 151 249 4 3.48 4 8.09gh_30_8.9 1 81 151 254 4 3.50 4 10.71gh_30_8.10 1 64 151 216 4 3.43 4 10.01gh_50_2.1(+) 17 377 251 1028 10 5.42 6 414.88gh_50_2.2 1 245 251 748 6 5.53 6 54.61gh_50_2.5(+) 1 356 251 1035 10 5.39 6 81.40gh_50_2.6 1 299 251 838 8 5.67 6 58.17gh_50_2.8 5 392 251 1096 7 5.40 6 160.36gh_50_2.9 1 266 251 784 6 5.37 6 122.63gh_50_2.10(+) 3 379 251 1061 10 5.43 6 151.25gh_50_3.1 9 159 251 548 6 4.85 5 134.04gh_50_3.2 3 207 251 774 8 4.88 5 65.79gh_50_3.3 1 160 251 559 5 4.83 5 61.69gh_50_3.4 11 146 251 513 6 4.92 5 65.89gh_50_3.5 35 205 251 599 6 4.91 5 106.29gh_50_3.6(+) 1 145 251 588 8 4.91 5 44.52gh_50_3.7(+) 1 210 251 810 8 4.96 5 62.48gh_50_3.8 37 194 251 549 6 4.82 5 280.30gh_50_3.9 15 262 251 872 6 4.77 5 232.97gh_50_3.10(+) 3 126 251 497 8 5.48 6 49.49gh_50_8.1(+) 1 330 251 970 10 5.91 6 62.98gh_50_8.2(+) 1 448 251 1275 10 5.71 6 72.81gh_50_8.3 1 309 251 890 6 5.46 6 47.81gh_50_8.4 1 277 251 890 6 5.42 6 47.30gh_50_8.5(+) 1 302 251 951 10 5.96 6 59.82gh_50_8.6(+) 1 340 251 977 10 5.63 6 63.76gh_50_8.7(+) 1 314 251 1033 10 5.93 6 64.93gh_50_8.8(+) 1 372 251 1146 10 5.90 6 65.34gh_50_8.9(+) 1 282 251 902 10 5.98 6 64.20gh_50_8.10(+) 1 267 251 820 10 5.96 6 61.15gh_50_9.1 3 191 251 687 7 4.70 5 73.18gh_50_9.2 1 213 251 691 6 4.63 5 72.23gh_50_9.3 1 172 251 566 6 4.69 5 76.16gh_50_9.4(+) 3 196 251 702 8 4.95 5 47.93gh_50_9.5(+) 13 216 251 702 8 4.72 5 167.04gh_50_9.7(+) 1 190 251 679 8 4.95 5 50.82gh_50_9.8(+) 1 215 251 685 6 4.66 5 70.08gh_50_9.9(+) 1 160 251 521 5 4.69 5 115.27gh_50_9.10 21 202 251 585 6 4.74 5 151.47gh_50_10.1(+) 1 182 251 638 8 4.78 5 58.58gh_50_10.2(+) 1 208 251 751 8 4.90 5 49.16gh_50_10.3(+) 1 181 251 618 8 4.80 5 63.40gh_50_10.4(+) 1 215 251 745 8 4.77 5 115.56gh_50_10.5(+) 7 276 251 944 8 4.85 5 162.35gh_50_10.6(+) 1 171 251 593 8 4.79 5 50.36gh_50_10.7(+) 1 198 251 711 8 4.93 5 54.82gh_50_10.8(+) 1 210 251 688 8 4.85 5 73.54gh_50_10.9(+) 1 277 251 941 8 4.93 5 66.44gh_50_10.10(+) 1 199 251 737 8 4.83 5 64.65

the number of columns generated during the enumeration,the upper bound computed by GRASP, the lower bound at theroot node, the optimal value and the CPU time (in seconds).The analysis that follows considers separately the geometricand the random instances.

In two of the 50 geometric instances in class C1 thesolution obtained by the linear relaxation corresponds to aninteger optimum. In all remaining cases, the optimal value ofthe linear relaxation when rounded up was equal to the inte-ger optimum. In this situation, because the coefficients in theobjective function are integral, the B&P algorithm can stopif a primal solution is known, whose cost is no more thanone unit apart from the dual bound. Also notice that in noinstances did the algorithm have to resort to branching. More-over, the computation times are often orders of magnitudesmaller than those required by branch-and-bound algorithmsand the previous models. All instances were solved in lessthan two minutes and 77% of them were solved in less than10 seconds.

The scenario observed above for geometric instances is notaltered if we consider the 61 random instances in class C1.Again, we have two instances whose optimal integer solutionwas computed by simply solving the linear relaxation. In theremaining instances, rounding up the optimal values of therelaxation produces the optimal integer value. In no instancesdid the algorithm have to resort to branching. The maxi-mum CPU time once again remained significantly smallerthan that for the B&B algorithms and the other models.The maximum time spent to prove optimality only exceeded1 minute for instances rh_50_1, rh_50_2 and rh_50_8and, even in these cases, by only a few seconds. In 80% of therandom instances in C1, the computation time stayed below30 seconds.

We now turn our attention to the instances in class C2.According to Aringhieri and Dell’Amico [1], these instanceswere generated to be feasible but, at least in some sense,“hard” to solve. To put it more precisely, each of theseinstances was generated so that none of the solutions pro-duced by a thousand runs of the randomized versions ofthe greedy algorithms proposed in [7] had the same cost asthe best known solution for that particular instance (see theoriginal article for more details).

In 10 out of the 134 geometric instances reported inTables 8 and 9, the optimal solution of the (SP) linearrelaxation was integer. Once again, by rounding up the opti-mal bounds from the linear relaxations of the remaininginstances, one gets the optimal integer values. Neverthe-less, it is interesting to notice that 18 instances requiredthe exploration of multiple nodes of the enumeration tree.This occurred more often for larger graphs. As an example,instancegl_50_10.3 forced the algorithm to visit 59 nodesto have its optimality proven. The higher degree of difficultyof these instances when compared with those in C1 can alsobe assessed from the slight increase in computation times.However, they still remain quite small because 94 instanceswere solved in no more than a minute, and 70 of them werecomputed in less than 15 seconds.




rl_15_2.1(∗) 1 19 76 38 3 3.00 3 0.59rl_15_2.2 1 19 76 50 4 3.13 4 0.75rl_15_2.3(∗) 1 21 76 44 3 3.00 3 0.90rl_15_2.4(∗) 1 23 76 39 3 3.00 3 0.88rl_15_2.5(∗) 1 19 76 30 3 3.00 3 0.66rl_15_2.6(∗) 1 14 76 34 3 3.00 3 0.52rl_15_2.7 1 17 76 37 4 2.99 3 0.60rl_15_2.8 1 19 76 38 3 2.96 3 0.65rl_15_2.9 1 15 76 33 4 3.06 4 0.35rl_15_2.10(∗) 1 17 76 35 3 3.00 3 0.60rl_15_5.1 1 13 76 32 3 2.96 3 0.51rl_15_5.2(∗) 1 11 76 25 3 3.00 3 0.48rl_15_5.3 1 15 76 37 3 2.95 3 0.53rl_15_5.4(∗) 1 11 76 25 3 3.00 3 0.41rl_15_5.5(∗) 1 19 76 43 3 3.00 3 0.61rl_15_5.6(∗) 1 11 76 25 3 3.00 3 0.43rl_15_5.7 1 13 76 32 3 2.95 3 0.50rl_15_5.8(∗) 1 11 76 25 3 3.00 3 0.41rl_15_5.9 1 13 76 32 3 2.96 3 0.52rl_15_5.10(∗) 1 11 76 25 3 3.00 3 0.41rl_25_3.1 1 53 126 146 4 3.49 4 4.48rl_25_3.2 1 53 126 126 4 3.53 4 4.29rl_25_3.3 1 47 126 129 4 3.50 4 2.65rl_25_3.4 1 49 126 132 4 3.56 4 3.88rl_25_3.5 1 49 126 134 4 3.50 4 4.24rl_25_3.6 1 45 126 137 4 3.61 4 4.04rl_25_3.7 1 45 126 119 4 3.50 4 3.07rl_25_3.8 1 45 126 122 4 3.50 4 3.15rl_25_3.9 1 44 126 120 5 3.58 4 4.79rl_25_3.10 1 45 126 117 4 3.50 4 3.53rl_30_2.1 1 73 151 180 5 3.86 4 8.87rl_30_2.2 1 66 151 179 4 3.89 4 6.07rl_30_2.3(+) 1 60 151 174 6 3.95 4 4.32rl_30_2.4 1 60 151 174 4 3.95 4 5.22rl_30_2.5 1 58 151 168 4 3.92 4 5.25rl_30_2.6 1 68 151 183 5 3.81 4 12.34rl_30_2.7 1 65 151 183 4 3.99 4 7.17rl_30_2.8 1 61 151 177 4 3.96 4 4.70rl_30_2.9 1 60 151 204 4 3.92 4 5.32rl_30_2.10 1 86 151 216 5 3.91 4 15.08rl_30_9.1 1 51 151 166 4 3.82 4 3.60rl_30_9.2 1 66 151 189 4 3.83 4 4.23rl_30_9.3 1 53 151 166 4 3.86 4 3.75rl_30_9.4(+) 1 62 151 179 6 3.90 4 3.73


rl_30_9.5 1 56 151 146 4 3.79 4 4.57rl_30_9.6 1 60 151 165 4 3.85 4 3.46rl_30_9.7 1 65 151 185 4 3.90 4 2.81rl_30_9.8 1 62 151 180 4 3.85 4 3.58rl_30_9.9 1 53 151 147 4 3.81 4 3.40rl_30_9.10(+) 1 63 151 177 6 3.85 4 5.02rl_50_2.1(+) 1 196 251 586 8 4.79 5 33.88rl_50_2.3(+) 1 164 251 520 8 4.93 5 21.46rl_50_2.4(+) 1 201 251 616 8 4.89 5 26.30rl_50_2.5(+) 1 172 251 555 8 4.83 5 20.26rl_50_2.6(+) 3 162 251 513 8 4.72 5 27.36rl_50_2.7(+) 3 194 251 559 8 4.81 5 26.52rl_50_2.8(+) 1 190 251 572 8 4.87 5 26.59rl_50_2.9(+) 1 171 251 571 8 4.87 5 27.27rl_50_2.10(+) 1 193 251 632 8 4.82 5 27.55rl_50_8.1(+) 1 174 251 552 8 4.98 5 26.50rl_50_8.3(+) 1 173 251 632 8 4.97 5 30.96rl_50_8.4(+) 1 191 251 591 8 4.99 5 37.29rl_50_8.6(+) 1 206 251 682 8 4.89 5 29.67rl_50_8.7(+) 1 178 251 514 8 4.97 5 23.69rl_50_8.8(+) 1 172 251 583 8 4.96 5 25.20rl_50_8.9(+) 1 169 251 563 8 4.99 5 34.11rl_50_8.10(+) 1 189 251 584 8 4.95 5 40.54rh_15_10.1 1 26 76 44 3 2.87 3 2.27rh_15_10.2 1 19 76 43 3 2.88 3 1.68rh_15_10.3 1 25 76 50 3 2.99 3 2.87rh_15_10.4(∗) 1 15 76 49 3 3.00 3 1.92rh_15_10.5 1 25 76 53 3 2.99 3 2.94rh_15_10.6(∗) 1 11 76 42 3 3.00 3 1.52rh_15_10.7(∗) 1 11 76 37 3 3.00 3 1.49rh_15_10.8(∗) 1 15 76 49 3 3.00 3 1.91rh_15_10.9 1 16 76 54 3 2.97 3 1.41rh_15_10.10(∗) 1 10 76 37 3 3.00 3 1.40rh_30_5.1 1 62 151 206 4 3.32 4 27.23rh_30_5.2 1 65 151 210 4 3.35 4 16.22rh_30_5.3 1 61 151 195 4 3.29 4 12.09rh_30_5.4 1 58 151 183 4 3.36 4 16.11rh_30_5.5 1 61 151 214 4 3.39 4 19.07rh_30_5.6 1 58 151 195 4 3.35 4 16.39rh_30_5.7 1 58 151 195 4 3.36 4 12.32rh_30_5.8 1 50 151 192 4 3.38 4 17.13rh_30_5.9 1 58 151 196 4 3.38 4 17.35rh_30_5.10 1 49 151 186 4 3.37 4 9.61

The random instances in C2 seem to be easier to solvethan the geometric ones. There are 87 instances reported inTable 10 and, for 17 among them, the optimal solution of thelinear relaxation of (SP) is integral. Rounding can be usedonce again to reach the optimal integral values in all remain-ing instances. The maximum number of nodes explored inthe enumeration tree was 3, and in all but two instances onlythe root node was necessary to conclude that an optimal solu-tion was at hand. None of the instances required more than aminute of computation. In fact, 40 seconds was the maximumCPU time spent to halt the search.

4.6. Dealing with Infeasible Instances

The inability of IP models and algorithms to detect infea-sibility for SRAP was pointed earlier in the literature. In [1]

the authors mention that 57 hours of CPU were necessaryon average to prove infeasibility using a PC Pentium III/600with 512 MB of RAM, and running under the Linux operatingsystem. We had similar experiences even when using B&Bwith the (CM) formulation. Thus, we decided to investigatefurther the capabilities of the B&P algorithm by testing iton this particular issue. To this end, we ran B&P on the 12instances in class C3which were conjectured to be infeasiblein [7].

Although our goal was to work with infeasible instances,when we started this last experiment, we had no proof that theinstances in class C3 fulfilled this property and, therefore, wetested them all. As a consequence, we later discovered thatsome of them were actually feasible. Somehow, one couldargue that these instances were not appropriate for our goals.


TABLE 11. Results of the (SP) model for C3 instances.

Instance #Nod #Sub #Ini #Gen zub zr z∗ Time

rl_15_7 1 17 76 38 16 31.9 — 1.13rl_25_3 1 37 126 106 26 30.6 — 3.11rl_30_2 1 51 151 157 31 37.3 — 4.99rl_30_9 1 55 151 158 31 35.9 — 4.65rl_50_2 1 139 251 445 51 89.7 — 19.71rl_25_1 1 36 126 102 6 3.4 4 3.32rl_30_3 1 60 151 169 6 3.7 4 6.16rl_30_6 1 59 151 198 6 3.9 4 4.36

Nevertheless, the feasibility status of those instances was firstestablished by our code and, for this reason, we decided toreport the results here.

The primal bound was initially set to � n2�+1. As explained

in Section 3, this value was used whenever a feasible solutionwas not available. This was the case for all instances of C3when we started the tests.

The results for eight instances in C3 are summarized inTable 11, whose columns have the usual meanings. Noticethat, according to the specifications in Section 3, if theoptimal value of the linear relaxation exceeds � n

2� then wecan conclude that the instance is infeasible. Comments onour experience in solving the other 4 instances of C3 arepresented in Subsection 4.7.

Remarkably, the B&P algorithm proved the infeasibilityof 5 out of the 12 instances in less than 20 seconds. Thosefive instances, namely rl_15_7, rl_25_3, rl_30_2,rl_30_9, and rl_50_2 were not known to be infeasi-ble. On the other hand, our algorithm was also able to findthe optimum for three other instances: rl_25_1, rl_30_3and rl_30_6. Again, the computation was completed inseconds. However, these three instances were already knownto be feasible (see [1]). But it is worth noting that amongthese three cases the heuristic GRASP only found a feasiblesolution for instance rl_30_3.

It is also interesting to mention that we have tried ourcode on the 13 instances presented in Table 10 of [7]. Inthat work, the authors could not establish whether theseinstances were feasible or not. We found out that nine ofthem are infeasible. In the remaining four instances, namelygh_25_5, gh_50_2, gh_50_8, and gh_50_10, weexperienced problems in running the codes that are discussedbelow.

4.7. Unsolved Instances

In the prior subsections, no results of B&P are given fora few cases in the different classes of instances considered.Unfortunately, for those instances, the B&P algorithm raninto a memory problem. The problem occurred in internalstructures of the commercial solver XPRESS, which we haveno access to. The origin of the error seems to be related tothe number of matrices that are simultaneous stored. In fact,we did not pay too much attention in our implementation to

memory usage because our early experiments with feasibleinstances showed that very few nodes were explored by B&P.Maintaining matrix data on active nodes made the algo-rithm faster and did not seem to cause memory problems.As we found out later, this is not always the case. Someinstances, even feasible ones, may require the exploration oflarger portions of the state space. We believe that with exten-sive changes to our data structures we could overcome thisobstacle and possibly reach a conclusion concerning the fea-sibility of the four instances remaining in C3 whose statusis still open. Although these changes might affect the run-ning time of B&P, the algorithm will probably remain verycompetitive.

For additional information, we checked the number ofgenerated columns and the number of nodes explored inthe enumeration tree for those instances in which the codecrashed. In all such cases, the number of nodes was higherthan 59 and the number of generated columns typicallyranged between 1000 and 2500 columns.

5. CONCLUSIONS

In this article we introduced new IP formulations forSRAP. Extensive computational experiments were carriedout on benchmark instances taken from the literature. Amongthe models with polynomial number of variables, our model(CM) proved to be the most efficient. The branch-and-bound(B&B) algorithm based on our model solved more instancesand was faster than that based on models proposed ear-lier. Moreover, we have also introduced a set partitioningformulation of SRAP with one extra knapsack constraint.To compute this model, which has an exponential numberof variables, we have designed and implemented a branch-and-price (B&P) algorithm. Our B&P code proved to belargely superior to the B&B codes independent of whichcompact formulation was used in the latter. Not only doesB&P run almost two orders of magnitude faster on aver-age than the fastest of its competitors, but it is also ableto rapidly demonstrate the infeasibility of some instanceswhich, otherwise, would require hours, if not days, by othermethods. Contrary to earlier statements in the literature,our results indicate that with the stronger formulation andthe branch-and-price algorithm proposed here, integer pro-gramming can indeed be a practical approach for solvingSRAP.

As for future directions in this research, we believe thatsome improvements of the B&P code should be consid-ered. This includes the implementation of more efficient datastructures for a better usage of memory resources. Also,we did not investigate how degenerate the (SP) model is.Many set partition models reported in the literature sharethis undesirable property. Techniques to deal with degener-acy in column generation have been proposed in the literature(cf., [17]). It would be interesting to know if (SP) suffersfrom degeneracy and, if so, to check whether the incorpo-ration of some of these methods in B&P would improve itsperformance.


procedure GRASP-construction-phase(S);1. for u ← 1 to n do2. Ru ← {u}; π[u] ← Ru;3. end for4. E′ ← E;5. while E′ = ∅ do6. Build the set L of edges with the β largest

demands in E′;7. Randomly select an edge (u, v) in L;8. if π[u] ∪ π[v] is a feasible ring then9. E′ ← E′ \ {(w, w′)|w ∈ π[u] and w′∈ π[v]};10. for all vertices w ∈ π[v] do π[w] ← π[u];11. else E′ ← E′ \ {(u, v)};12. end while;13. return the solution S with the rings constructed above;end GRASP-construction-phase.

FIG. 2. Construction phase of GRASP.

APPENDIX: HEURISTIC FOR GENERATINGUPPER BOUNDS

In this appendix we explain how we generated the ini-tial primal bounds for SRAP that were used in all integerprogramming models discussed in Section 2. The procedurewe applied belongs to a class of meta-heuristics known asGRASP (Greedy Randomized Adaptive Search Procedure)and proposed in [6]. In a basic GRASP algorithm, a constantnumber of iterations is executed, each of which is composedof two phases. The first one is a greedy randomized construc-tion phase, while the second one is a local search procedure.The randomization of the construction phase is implementedthrough a change in the standard greedy choice step. Ratherthan bringing the element with the best value according to agiven criterion, a list of candidate elements is built with theβ best elements, and one of them is randomly chosen to beincorporated to the solution. Here, both β and the total num-ber of iterations performed by the algorithm are parametersto be fixed a priori. Below we summarize the GRASP thatwe implemented for SRAP. However, before we continue,we want to emphasize that our only purpose in implementingthis meta-heuristic was to have a good incumbent solution todrive the exact methods. Therefore, we did not run extensivetests to tune the code and, by no means do we claim that ourheuristic outperforms other existing ones.

From now on, the term GRASP is used to denote our spe-cific implementation designed to solve SRAP instances. Wefirst notice that it is possible for GRASP to return infeasiblesolutions. Of course, this must be allowed, because some-times we cannot decide in reasonable computing time ifthe instance has a solution or not. Even when the construc-tion phase discovers that the instance is feasible, infeasiblesolutions can be visited. The goal here is to allow more flexi-bility to move along the search space. However, the objectivefunction has been modified to make feasible solutions moreattractive than infeasible ones. To explain the changes in theobjective function, we define the following values associatedwith a feasible solution S with vertex sets V1, . . . , V�:

procedure GRASP-local-search-phase(S);1. Initialize S as the solution returned by the construction phase;2. (∗ First neighborhood ∗)

3. Let {R1, R2, . . . , Rk} be the rings in S;4. for i ← 1 to k − 1 do5. for j ← i + 1 to k do6. for all u ∈ Ri do7. Let S′ be the solution obtained from S by

moving vertex u from Ri to Rj ;8. if c(S) > c(S′) then S ← S′;9. (∗ Second neighborhood ∗)

10. for i ← 1 to k − 1 do11. for j ← i + 1 to k do12. for all u ∈ Ri and v ∈ Rj do13. Let S′ be the solution obtained from S by

exchanging vertices u and v among rings Ri and Rj ;14. if c(S) > c(S′) then S ← S′;end GRASP-local-search-phase.

FIG. 3. Local search phase of GRASP.

F = max{0, �D}, (44)

R = max{0, max{ j ∈ {1, . . . , �} : dj − B}}, (45)

where �D and dj are defined as in (20) and (19), respec-tively. Now, the cost of this solution in the modified objectivefunction is computed by the formula

c(S) = � + αF + ξR, (46)

where α and ξ are penalization parameters for those solutionsviolating the capacity of any ring, including the federal ring.In our computations, both α and ξ were set to 1. This meansthat every unit of demand in excess in the local ring with themost violated capacity constraint and in the federal ring costsas much as the inclusion of an extra ring in the solution.

We now turn our attention to the construction phase ofGRASP. The algorithm is an adaptation of the edge-basedheuristic presented in [7] to include randomization. It alwaysstarts with a solution containing n rings with only one vertexassigned to each. Those rings are feasible because, otherwise,the instance itself is infeasible. Therefore, the only constraintthat can be violated is the one that imposes a limit on thedemand on the federal ring. At each iteration, the union oftwo rings into a single one is considered. Such a union isaccepted only if the resulting ring is feasible. Clearly, thisoperation reduces the amount of demand on the federal ring.

procedure GRASP;1. Initialize c∗ ← +∞ and S∗;2. for i ← 1 to 2n do3. GRASP-construction-phase(S);4. GRASP-local-search-phase(S);5. if c(S) < c∗ then6. Update: c∗ ← c(S) and S∗ ← S;7. return S∗;end GRASP.

FIG. 4. The GRASP algorithm.


TABLE 12. Summary of results for GRASP.

Class % opt % fails Max

C1 91 0 34%C2 59 27 29%

Total 70 18

The greedy choice is guided by the demands on edges thatare in the multicut set of the rings. The larger the demandon the edge, the better is the edge. As we have seen earlier,the randomization will not force us to pick the best edgeaccording to this criteria. Instead, the selected edge is chosenrandomly among the β ones with smaller demand. The stepsof the construction algorithm are summarized in Figure 2.The variable π [u] denotes the index of the ring containingvertex u of V .

The local search phase is based on two types of neigh-borhoods. The first neighborhood considers the possibility ofmoving every vertex u from any of the existing rings differentfrom π [u]. The second neighborhood considers all possibil-ities of exchanging pairs of vertices among different rings.The neighborhoods are inspected in that order as suggestedin the algorithm in Figure 3. The values of c in this algorithmare those defined in (46).

Finally, Figure 4 gives an overview of our GRASP. Noticethat the number iterations we allowed is twice the numberof vertices in the graph. Although this number is modestcompared to other implementations of this meta-heuristicsfor other combinatorial problems, this is compensated by thefact that we ran our GRASP for the nine distinct values of theparameter β ∈ {2, . . . , 10}.

From Table 12 we can assess the results from our GRASP.The statistics shown there refer to the best solutions obtainedfor β ∈ {2, . . . , 10} for all instances in classes C1 and C2(see Subsection 4.1), 341 in total. Columns “% opt” and “%fails” refer to the percentage of instances where at least one ofthe nine GRASP executions achieved the optimum and to thepercentage of instances for which all nine runs were unableto find a feasible solution, respectively. Considering solelythose instances where the heuristic produced a feasible butnot an optimal solution, we calculated the values displayed incolumn “max,” which give the maximum percentage of thedeviation (µ) between the optimum (z∗) and the cost of thesolution computed by GRASP (zG) according to the formula

µ = z∗ − zG

z∗ × 100.

Results are presented for each of the instance classes. As canbe seen from Table 12, our simple GRASP is still able to pro-duce relatively good bounds. It is clear, however, that there isstill room for improvements, especially to reduce the occur-rence of failures. Our experiments showed that failures tendto increase with instance sizes. Also, as expected, instances inclass C2 concentrate most of the failure cases. As mentionedearlier, those were especially designed to be hard instancesto solve heuristically.

REFERENCES

[1] R. Aringhieri and M. Dell’Amico, Comparing metaheuristicalgorithms for sonet network design problems, J Heuristics11 (2005), 35–57.

[2] E. Balas and M. Padberg, Set partitioning: a survey, SIAMRev 18 (1976), 710–760.

[3] C. Barnhart, E.L. Johnson, G.L. Nemhauser, M.W.P. Salvels-bergh, and P.H. Vance, Branch-and-price: Column generationfor solving huge integer programs, Oper Res 46 (1998),316–329.

[4] Dash Optimization, Inc. XPRESS-MP: user manual, 1999,Version 12.05.

[5] A.A. Farley, A note on bounding a class of linear program-ming problems, including cutting stock problems, Oper Res38 (1990), 922–923.

[6] T.A. Feo and M.G.C. Resende, Greedy randomized adaptivesearch procedures, J Global Optimizat 6 (1995), 109–133.

[7] O. Goldschmidt, A. Laugier, and E.V. Olinick, SONET/SDHring assignment with capacity constraints, Discrete ApplMath 129 (2003), 99–128.

[8] M. Grötschel and M. Padberg, “Polyhedral theory,” The trav-eling salesman problem: A guided tour of combinatorialoptimization, E.L. Lawler, J.K. Lenstra, A.R. Kan, and D.B.Shmoys (Editors), John Wiley & Sons, New York, 1985,pp. 251–305.

[9] S. Holm and M.M. Sorensen, The optimal graph partition-ing problem: Solution method based on reducing symmet-ric nature and combinatorial cuts, O.R. Spektrum 15 (1993),1–8.

[10] E.M. Macambira, Modelos e algoritmos de programaçãointeira no projeto de redes de telecomunicações, Ph.D. the-sis (in Portuguese), COPPE, Universidade Federal do Rio deJaneiro, Rio de Janeiro, Brazil, 2003.

[11] E.M. Macambira, N. Maculan, and C.C. de Souza, Integerprogramming models for the sonet ring assignment prob-lem, Technical Report XX/2005, Institute of Computing,State University of Campinas (UNICAMP), Campinas (SP),Brazil, 2005.

[12] S. Martello, D. Pisinger, and P. Toth, New trends in exactalgorithms for the 0-1 knapsack problem, Eur J Oper Res123 (2000), 325–332.

[13] G.L. Nemhauser and L.A. Wolsey, Integer and combinatorialoptimization, John-Wiley & Sons, New York, 1988.

[14] D.M. Ryan and B.A. Foster, “An integer programmingapproach to scheduling,” Computer scheduling of pub-lic transport urban passenger vehicle and crew schedul-ing, A. Wren (Editor), North-Holland, Amsterdam, 1981,pp. 269–280.

[15] H.D. Sherali and J.C. Smith, Improving discrete model rep-resentations via symmetry considerations, Manage Sci 47(2001), 1396–1407.

[16] A. Sutter, F. Vanderbeck, and L. Wolsey, Optimal placementof ADD/DROP multiplexers: Heuristic and exact algorithms,Oper Res 46 (1998), 719–728.

[17] J.M. Valério de Carvalho, Using extra dual cuts to accel-erate column generation, INFORMS J Comput 17 (2005),175–182.

[18] F. Vanderbeck and L.A. Wolsey, An exact algorithm for IPcolumn generation, Oper Res Lett 19 (1996), 151–159.


2009 macambira.maculan

Documents