branch-and-price algorithms for the dual bin packing and maximum cardinality bin packing problem

European Journal of Operational Research 170 (2006) 416–439

www.elsevier.com/locate/ejor

Discrete Optimization

Branch-and-price algorithms for the dual bin packingand maximum cardinality bin packing problem

Marc Peeters a,*, Zeger Degraeve b

a Electrabel, Place de l’Universite 16, 1348 Louvain-la-Neuve, Belgiumb London Business School, Sussex Place, Regent�s Park, London NW1 4SA, UK

Received 6 November 2002; accepted 16 June 2004Available online 7 October 2004

Abstract

There appear to be two versions of the Dual Bin Packing problem in the literature. In addition, one of the versionshas a counterpart in the cutting stock literature, known as the Skiving Stock Problem. This paper outlines branch-and-price algorithms for both. We introduce combinatorial upper bounds and well-performing heuristics from the literaturein the branch-and-price framework. Extensive computational tests indicate that the branch-and-price approach is supe-rior to the existing branch-and-bound procedures, based on combinatorial bounds. The tests illustrate the influence ofdifferent problem characteristics on the computation time and the limits of the branch-and-price approach.� 2004 Elsevier B.V. All rights reserved.

Keywords: Integer programming; Packing; Branch-and-price

1. Introduction

There appear to be two versions of the dual bin packing problem in the literature. Both problems areclosely related to the well-known bin packing problem (BPP) and the Cutting Stock Problem (CSP), whichare extensively studied in the literature. A first version is stated as follows. Given a set of n items withweights w1, . . .,wn and availabilities d1, . . .,dn, fill as many bins as possible, such that the weight of eachbin is greater than or equal to the capacity c of the bin. This version is discussed in Labbe et al. [15]and we will refer to it as DBP. As real world application, they mention the allocation of tasks to agents,

0377-2217/$ - see front matter � 2004 Elsevier B.V. All rights reserved.doi:10.1016/j.ejor.2004.06.034

* Corresponding author. Tel.: +32 10 485174; fax: +32 10 485109.E-mail addresses: [email protected] (M. Peeters), [email protected] (Z. Degraeve).

mailto:[email protected]

mailto:[email protected]

M. Peeters, Z. Degraeve / European Journal of Operational Research 170 (2006) 416–439 417

given that each agent requires a minimum level of activity to be viable. Thus, in case of temporal excesscapacity, the objective is to keep as much as possible production units active. In addition, Johnson et al.[14] present a cutting stock counterpart of this problem, named the Skiving Stock Problem (SSP), in whichsmaller rolls are joined to form larger rolls. If wi, i = 1, . . .,n, represent roll widths instead of weights, and c

is the required roll width, then the objective in the SSP is to make as many big rolls of at least length c aspossible, given the available stock of smaller items.

The second version of the dual bin packing problem is defined as follows. Given a limited number m ofbins with capacity c, maximize the number of items that can be packed from a set of n items with weightsw1, . . .,wn and availabilities d1, . . .,dn without exceeding the capacity of the bins. For both problems, theitem weights and availabilities are strictly positive. This second version is discussed in e.g. [1,3,21,16]. Labbeet al. [16] call this version the Maximum Cardinality Bin Packing Problem (CBP) and throughout thispaper, we will use this terminology and refer to the second version as CBP. As real world application, theymention, among other applications, the assignment of storage to variable length records, such that the re-cords stored in fast memory is maximized in order to obtain a minimum average access time to records.

In this paper, we present branch-and-price algorithms for both problems. During the last decade, manyhard integer programming problems have been successfully solved exactly with branch-and-price. The firstpapers on branch-and-price or integer programming column generation are [8] and [9] on routing problemsand Savelsbergh [22] presents an efficient branch-and-price algorithm for the Generalized Assignment Prob-lem. For the CSP and BPP, branch-and-price algorithms are presented in e.g. [24,25,5,7]. These are allbased on the fundamental idea of Gilmore and Gomory [12] of generating cutting patterns or packing pro-posals in a subproblem, while the demand constraints are considered in a master program. A generated cut-ting pattern or packing proposal represents a column in the master program.

An optimal procedure for the DBP is developed in [15] and for the CBP in [16]. Both papers give realworld applications, an overview of heuristics, the derivation of upper bounds, a branch-and-bound algo-rithm to solve the problems to optimality, and computational results. The computational results indicatethat the upper bounds are tight and heuristics perform well on the generated data sets. However, some in-stances cannot be solved within a limit on the number of nodes. This is due to a gap between the upperbounds at the root node and the optimal solution, which cannot be closed by their branching strategy.We will present a new formulation for both problems in Section 2 that can be solved with column gener-ation. The upper bound provided by the LP relaxation of this formulation turns out to be almost alwaysequal to the optimal solution. Section 3 presents upper and lower bounds for the problems. Section 4 pre-sents the branch-and-price algorithms, that overcome the weaknesses of the branch-and-bound procedure,while preserving its strengths, i.e., we will integrate the excellent combinatorial upper bounds and effectiveheuristics in our branch-and-price method. As a result, the computationally more expensive column gener-ation procedure will only be needed whenever the heuristic solutions differ from the combinatorial upperbounds computed at, the root node. Similarly, the branch-and-price algorithm will only be needed, when-ever the LP bound differs from the heuristics. In Section 5, we give the computational results and we con-clude in Section 6.

2. Formulations

2.1. Dual bin packing problem

For the DBP, let P be the set of all feasible bin assignments, P ¼ p 2 Znþ :Pn

i¼1wipi P c� �

, where Znþ

represents the n-dimensional space of non-negative integer numbers and p � (p1, . . .,pn) a feasible packingcombination, and let zp be number of times to use combination p in the solution, then we can state the for-mulation, called the master program (DMP) as follows:

418 M. Peeters, Z. Degraeve / European Journal of Operational Research 170 (2006) 416–439

ZDMP ¼ MaxXp2P

zp ðDMPÞ ð1Þ

subject toXp2P

pizp 6 di; i ¼ 1; 2; . . . ; n; ð2Þ

zp 2 Zþ 8p 2 P : ð3Þ
This formulation can be solved with regular column generation. Let p denote the optimal dual price vector ofthe availability constraints (2) of the restricted master problem, i.e. problem (1)–(3) with only a subset of allthe packing proposals from the set P. The pricing problem to find a column p, that improves the restricted
master LP objective function value, denoted by ZDMP

LP , is then the following bounded knapsack problem:

tðpÞ ¼ MinXni¼1

pixi :Xni¼1

wixi P c; xi 2 f0; 1; . . . ; uig; i ¼ 1; . . . ; n

( ): ð4Þ

The upper bounds ui are initially set equal to the availability di of the corresponding item. If the reducedcost of a new column is negative, i.e., t(p) � 1 < 0, the new column is added to the master problem andcolumn generation continues. Otherwise, we have an LP optimum for DMP.

To solve the bounded knapsack problem, we do not transform it into its maximization form as is sug-gested in [18], but solve it directly with our custom-made branch-and-bound procedure. Our branch-and-bound procedure is based on the implicit enumeration scheme of Gilmore and Gomory [13] as described in[2] and the lower bounds used are appropriate modifications of the upper bounds presented in [18] for themaximization form of the bounded knapsack problem. In addition, we use a new bound. Let pmin be thesmallest dual price of all n items and wmax be the largest item weight, then the following expression is alower bound: Lnew = pmin * dc/wmaxe. Observe that dc/wmaxeis the minimum number of items needed to ex-ceed the bin capacity. If we multiply this by the minimum dual price, we obtain clearly a lower bound forthe knapsack problem (4).

2.2. Maximum cardinality bin packing problem

The CBP can be formulated similarly. Let P ¼ p 2 Znþ :Pn

i¼1wipi P c� �

be the set of feasible bin assign-ments, then the master program (CMP) can be stated as follows:

ZCMP ¼ MaxXp2P

Xni¼1

pi

!zp ðCMPÞ ð5Þ

subject toXp2P

pizp 6 di; i ¼ 1; 2; . . . ; n; ð6ÞXp2P

zp 6 m; ð7Þ

zp 2 Zþ; p 2 P : ð8Þ

The expressionPn

i¼1pi presents the number of items packed in bin p and as a result the objective function (5)maximizes the number of items packed. Constraints (6) impose that no more then di units of item i can beused and constraint (7) imposes that the total number of selected bins does not exceed the limitm on the num-ber of bins. Let p be the vector of optimal dual prices of the availability constraints (6) of the restricted masterand q the dual price of constraint (7), then the pricing problem is the following bounded knapsack problem:

tðpÞ ¼ MaxXni¼1

ð1� piÞxi :Xni¼1

wixi 6 c; xi 2 f0; 1; . . . ; uig; i ¼ 1; . . . ; n

( ): ð9Þ


As long as the reduced cost is negative, i.e. q � t(p) < 0, a new column will be added to the restrictedmaster. Otherwise, we have an LP optimum to CMP. Problem (9) is solved by a branch-and-bound proce-dure, based on the implicit enumeration scheme of Gilmore and Gomory [13] as described in [2] using theupper bounds presented in [18].

3. Lower and upper bounds

3.1. Dual bin packing problem

Our algorithm uses three upper bounds for DBP. We use two a priori upper bounds, namely the roundeddown ratio of the total number of items available and the minimum number of items needed to exceed thecapacity of the bin (U0) and the rounded down ratio of the total available weight of items and the bincapacity (U1), or

U 0 ¼Xni¼1

di

$ ,dc=wmaxe

%and U 1 ¼

Xni¼1

widi

$ ,c

%: ð10Þ

The third upper bound is the optimal LP solution of formulation (1)–(3) rounded down, or bZDMPLP c.

Heuristics are used in order to obtain lower bounds. The first heuristic starts with the largest item that isnot yet completely assigned to a bin, call it item k, which has a remaining availability uk, where uk is initiallyset equal to dk. We try to assign as much as possible of the remaining availability of item k to the currentbin, without exceeding the bin capacity. If all items k that are still available can be assigned to this bin, wego to the next item k + 1 and set the remaining availability equal to zero, i.e. uk = 0. If only a part of the ukitems can be assigned to the current bin, then we look for the smallest possible item j with positive uj thatmakes the current bin feasible. This implies that by assigning one unit of item j to the bin, the capacity willbe exceeded. This procedure continues, until all items are assigned or no feasible bin can be found anymorewith the remaining items.

The second heuristic solves consecutively the minimization form of the subset sum problem and is equiv-alent to the fill bin heuristic of Vanderbeck [25] for the CSP and the procedure SSH of Labbe et al. [15].After solving a subset-sum problem, the availability of the items is updated by removing the items assignedto the knapsack from the stock of available items. We continue this procedure as long as the solution valueof the first heuristic can be improved. This means that after solving a subset-sum problem, the a prioriupper bounds are recomputed over the items that are still available. Suppose that the heuristic has gener-ated k bins so far. If the sum of k and the new a priori upper bound is equal to or smaller than the solutionvalue of the first heuristic, the procedure stops.

3.2. Maximum cardinality bin packing problem

The algorithm uses three upper bounds. The two a priori upper bounds, presented in [15], are re-formu-lated below. We assume, without loss of generality, that the items are sorted in increasing order of weight,or, w1 < w2 < � � � < wn. We define the following notation:

• [s(j)]: The item k with the largest weight that can be put dk times in a knapsack with capacity j*c afterputting all smaller items in the knapsack, or

sðjÞ ¼ Max k 2 f1; 2; . . . ; ng :Xki¼1

widi 6 j�c

( )for j ¼ 1; . . . ;m;


• [Q(j)]: Upper bound on the number of items that can be packed in j bins, or

QðjÞ ¼XsðjÞi¼1

di þ j�c�XsðjÞi¼1

widi

! ,wsðjÞþ1

$ %for j ¼ 1; . . . ;m:

An upper bound on the number of items that can be packed in m bins is then U1(j) = Q(j) + bQ(j)/jc*(m � j), because bQ(j)/jc is an upper bound on the number of items that can be packed in each of theremaining (m � j) bins. Taking the minimum over all j, results in the following upper bound:

U 1 ¼ Minj¼1;...;m

U 1ðjÞ: ð11Þ

The second upper bound can be re-formulated as follows:

U 2ðkÞ ¼Xk�1

i¼1

di þ mbc=wkc:

If k is the smallest item, then mbc/wkcis an upper bound on the number of items that can be packed in m

bins, because bc/wkcis an upper bound on the number of items that can be packed in one bin. If k is not thesmallest item, then a valid upper bound can be found by assuming that all items i < k are in the optimalsolution. Consequently the second upper bound is then the minimum over all items:

U 2 ¼ Mini¼1;...;n

U 2ðiÞ: ð12Þ

The third upper bound is the rounded down value of the LP relaxation of formulation (5)–(8), bZCMPLP c.

Let U* be the best known a priori upper bound for the CBP, i.e. U � ¼ MinfU 1;U 2g, where the upperbounds U 1 and U 2 are stated in Eqs. (11) and (12) respectively, then we apply two bin packing heuristicson the U* smallest items, namely the first fit decreasing heuristic (see e.g. [18]) and the fill bin heuristic [25].If this results in a solution of not more than m bins, then we have obtained a proven optimal solution, be-cause we have packed a number of items equal to the upper bound in m bins. Otherwise, we proceed withthe branch-and-price algorithm, outlined in the next section.

4. Branch-and-price algorithm

The general structure of the algorithms for the DBP and CBP consists of four steps. First, we computethe a priori upper bounds and secondly we apply the heuristics, outlined in Section 2. If one of the heuristicsin step 2 discovers a solution equal to the best a priori upper bound U*, an optimal solution is found. Other-wise, we proceed to step 3, consisting of solving the LP relaxation of formulation (1)–(3) for the DBP orformulation (5)–(8) for the CBP. This is explained in the next Section 3.1. If one of the heuristics is equalto the LP upper bound, a proven optimum is found. Otherwise, we proceed to step 4, consisting of thebranch-and-price algorithm, explained in Section 3.2. Before proceeding, we remark that we use the samereduction criteria for the DBP as in [15]. These criteria identify pairs of items, for which it can be proven thatthere exists an optimal solution in which only the given pair is packed in the same bin. Based on the firstreduction criterion, all pairs (i, j) are assigned to a bin if wi + wj = c. For the second criterion, we refer to [15].

4.1. Solving the LP relaxation

To find the LP upper bound of formulation (1)–(3) and (5)–(8) in step 3, we do not uniquely rely on thesimplex method to compute the dual price vector, p to generate new columns. We have implemented a


combination of the simplex method and subgradient optimization as described in [6] and [7] for the CSPand BPP. This resulted in a reduction of the computation time to find the LP relaxation by a factor of 3on average. We exploit the fact that the Lagrange dual wLD is equal to the optimal LP solution of formu-lation (1)–(3) as showed by Geoffrion [11], or

wLD ¼ MinfwLRðpÞ j p P 0g ¼ ZDMPLP ; ð13Þ

where

wLRðpÞ ¼ U ��Max y �Xni¼1

pixi

!þXni¼1

pidi ð14Þ

subject toXni¼1

wixi P cy; ð15Þ

y 2 f0; 1g; xi 2 f0; 1; . . . ; dig i ¼ 1; . . . ; n: ð16Þ

Note that U* refers to the best a priori upper bound. This hybrid simplex method/subgradient optimi-zation procedure (HYP) essentially consists of a nested double loop. After initializing the master problemwith the bin assignments generated by the heuristics, we first compute, in the outer loop, the dual pricesusing the simplex method. These dual prices are used as starting values for the subgradient optimizationprocedure in the inner loop. For a set of dual prices, we look for a solution of the Lagrange problem(14)–(16). Therefore, we first solve the minimization form of the knapsack problem of Eq. (4) and denotethe optimal solution vector as x� ¼ ðx�1; . . . ; x�nÞ. If the optimal solution of this problem is less than one, orPn

i¼1pix�i < 1, we set y-variable in problem (14)–(16) equal to 1. Otherwise, we set y and every xi,i = 1, . . .,n, equal to 0. Then, we can compute the Lagrange function of Eq. (14). Subgradient optimizationis used to update the dual prices using textbook update formulas, namely:

pkþ1i ¼ pk

i þ tkðdi � U �x�i Þ; i ¼ 1; . . . ; n;

tk ¼ kðwðpl;kÞ � LÞPni¼1ðdi � U �x�i Þ

2;

where L denotes a lower bound on the Lagrange dual and is initially set equal to the best heuristic solutionfound and the parameter k is chosen to be 1. Once the LP relaxation value of the restricted master, i.e. pro-gram (1)–(3) with only the columns that are generated so far, becomes greater than the initial lower boundL, we replace L with the optimal solution of the restricted master rounded down, denoted as bZDMP

LP c. We dothis, because the subgradient optimization procedure will converge to the Lagrange dual, wLD, which isequal to the LP relaxation of the master problem (1)–(3) ZDMP

LP . For every set of dual prices, the Lagrangefunction wLR(p) (14) is greater than or equal to the Lagrange dual wLD. On the other hand, the optimal LPrelaxation of the restricted master Z

DMP

IP is a lower bound on this value. To summarize, the following rela-tionships hold: wLRðpÞ P wLD ¼ ZDMP

LP P ZDMP

LP . As a result, the optimal LP relaxation value of the lastsolved restricted master can be used as the lower bound in the subgradient optimization procedure.

We impose a limit on the number of subgradient optimization iterations of the inner loop equal to thenumber of different items n. In addition, the inner loop is halted, whenever the reduced cost of a new col-umn is non-negative, or

Pni¼1p

ki x

�i � 1 P 0, the vector pk denotes the vector of dual prices at the kth iter-

ation of the subgradient optimization procedure. Next, all columns generated during the subgradientoptimization phase are added to the master problem at once which is then resolved with the simplex me-thod. This gives a new set of dual prices p0 that are used as starting values for the next subgradient opti-mization phase. The HYP continues until one of the following 2 stopping criteria is met, namely:


(i) For a given set of dual prices pk, it holds that the rounded down value of the Lagrange relaxation isequal to the LP relaxation of the last solved master problem or to the best heuristic solution, orbwLRðpkÞc ¼ MinfbZDMP

LP c; Lg.(ii) The reduced cost of the subproblem using the initial dual price obtained using the simplex method is

non-negative, or v(p0) � 1 P 0.

A more extensive discussion including the several advantages of using the HYP can be found in [6] or [7].The main advantage is that solving the master problem as an LP is not required each time to obtain new dualprices. Performing an iteration of the subgradient optimization procedure is computationally much lessexpensive. At each subgradient iteration, we obtain a new column and these columns are ‘‘good’’, becausethe dual prices found with subgradient optimization converge towards the dual prices of the master at the LPoptimum. Therefore, we can expect that columns necessary to find the optimal LP solution will be generatedduring the subgradient optimization phase. A second advantage is the above-mentioned first stopping crite-rion that can help to avoid the tailing-off effect, typical for column generation algorithms (see e.g. [26]).

A pure subgradient optimization procedure has not been taken into consideration, because it does notprovide a primal solution we need to base our branching decisions on. Moreover, there is no ‘‘exact’’ stop-ping criterion for the pure subgradient optimization procedure, the dual prices are only approximatelyequal to the optimal dual prices of the master LP and the upper bound would be somewhat less tight.

4.2. Branching scheme

The branch-and-price algorithm is an adaptation of the algorithm for the CSP of [7], First, we look for asolution equal to the LP upper bound bZDMP

LP c, called the target value. If we do not find such a solution,which is known is when the procedure backtracks to the root node, we decrease the target value by one,and so on. This practice is widely used in the CSP literature (see e.g. [7,27]). In order to find an integer solu-tion for the DBP, we apply single column branching to the master problem DMP. More precisely, we use abinary branching tree where, at the left branch, a column zp must be greater than or equal to a lower boundlbp and at the right branch, column zp must be smaller than the lower bound, or

zp P lbp and zp 6 lbp � 1: ð17Þ
A complication arises at the right branch. We must avoid that the columns, whose corresponding LP valueis restricted by a single upper bound, price out again during the column generation procedure. We use theidea of [5] and pass a list of forbidden columns to the subproblem. Each time, our branch-and-bound pro-cedure to solve the minimization form of the knapsack subproblem, discovers a candidate incumbent solu-tion, we check whether this solution is contained in the forbidden list. If so, the incumbent is not updatedand the branch-and-bound procedure continues. We opted for this branching scheme, because of its sim-plicity and its good performance for the standard CSP [7].
First of all, we use the branches to focus on the residual problem, i.e., a DBP where the availability vec-tor is equal to the original availability minus the availability consumed by the rounded down LP solution.This approach is common in the CSP literature (see e.g., [7,27]). Let zp denote the value of column p in therestricted master problem, then we add sequentially for every column with an LP relaxation value greaterthan 1, a branching constraint zp P lbp ¼ bzpc. As a result, we can backtrack on the residual problem, if itturns out that we focussed on the wrong residual problem. After focussing on die residual problem, we ap-ply the first packing heuristic outlined in Section 2 on the residual problem. If the sum of all lower boundsand the solution of the packing heuristic are equal to the target value, a proven optimal solution is found.

Next, ‘‘effective’’ branches are added to the master problem. We select a column with fractional value inthe master and add the two branches of Eq. (17) to the tree, where lbp ¼ bzpc þ 1, and first investigate theleft branch, zp P lbp.


After adding a left branch to the master, we update the availabilities for each item, i.e.ui ¼ di �

Pp2P pilbp; i ¼ 1; 2; . . . ; n, and compute the a priori upper bound U2 of Eq. (10) over the remaining

availabilities. If the sum of the upper bound and the sum over all lower bounds imposed on the columns ofthe master problem is smaller than the target value, the node can be pruned. Otherwise the master is re-optimized and if necessary the HYP is used to generate columns. A node can be pruned, if the value ofthe optimal LP relaxation rounded down bZDMP

LP c is smaller than the target value. The updated availabilitiesui, i = 1,. . .,n, are also used as upper bounds to solve the knapsack subproblem (4) in order to prevent gen-erating columns that can only take a fractional value in the master LP. If the remaining availability of anitem is lower than the number of units of that item in column p, i.e. ui < pi, then column p can only take thevalue of its current lower bound lbp plus a fraction in the master problem. Since we are looking for an inte-ger solution, we can fix this column by setting an upper bound equal to the current lower bound on thatcolumn: zp 6 lbp, if $i 2 {1,2, . . .,n} : pi > ui. We do not have to add this column to the forbidden list, sinceit is not in the feasible region of the subproblem anymore, given the update of upper bounds for the pricingproblem. The procedure terminates, if there is no fractional column anymore in the LP relaxation and if themaster LP value is equal to the target value.

The branch-and-price algorithm for the CBP is identical, except for the use of a priori lower bounds toprune a node in the branch-and-bound tree and the re-application of the packing heuristics when the LPbased bound improves the best a priori upper bound, or bZCMP

LP c < U �.

5. Numerical experiments

We have programmed our procedures for the DBP and CBP in Fortran 77 using the WATCOM FOR-TRAN compiler version 10.6 and linked with the industrial LINDO optimization library version 5.3 [23] tosolve the master LP�s. The experiments were performed on a COMPAQ Armada 700M, Intel Pentium III,500MHz, using Windows NT as operating system. First, we will compare our procedure, named hereafter‘‘B&P’’, with the procedures of Labbe et al. [15] for die DBP and with Labbe et al. [16] for the CBP, named‘‘LA’’. The procedures LA for the DBP and CBP were tested on a VAX station 3100/30, with speed com-parable to a PC486/33. The PC486/33 is roughly about 70–90 times slower than our Pentium III 500MHzPC, according to [10]. All computation times are given in seconds, possibly followed by the number of un-solved instances in brackets. The procedure LA imposes a limit on the number of branch-and-bound nodesand B&P sets a time limit of 900 seconds. To generate the instances, we use a modification of the portableproblem generator for the cutting stock problem [4]. If identical item weights are generated during the con-struction of the instances, only one item weight is considered and the availability is incremented. Secondly,we will investigate the behaviour of the algorithm on many different classes of test instances in an attemptto characterize the problem parameters that influence the performance of the algorithm.

5.1. The dual bin packing problem

5.1.1. Data sets

Our branch-and-price algorithm is tested on the same instances as the algorithm of Labbe et al. [15] forthe DBP. They use 10 randomly generated instances for each of the 126 combinations of the following threeparameters:

Number of generated items: n0 ¼ 10; 20; 40; 60; 80; 100;

Capacity: c ¼ 100; 120; 150; 200; 300; 400; 500;

Weight interval ½wm; 99�: wm ¼ 1; 20; 50:

Observe that n 0 is not equal to the number of different items, but to the sum of the availabilities of the items:n0 ¼

Pni¼1di, where n is the number of different item weights. The computational tests will show that these


instances are not challenging for our branch-and-price algorithm. Therefore, we extend the data set pro-posed in [15]. In column generation algorithms for the standard CSP, the solution times are correlatedto the number n of different items, and not much to the total number of items n 0 (see e.g. [7]). The weightintervals of [15] are small, and, hence, increasing the number of items drawn from it, will not drasticallyincrease the number of different items n. Therefore, we enlarge the weight intervals and the bin capacitieswith a factor of 10 and draw 20 instances for each combination of the following three parameter values:

TableDBP,Pentiu

wm

1

20

50

Number of generated items: n0 ¼ 60; 80; 100; 250; 500;

Weight interval ½wm; 999�: wm ¼ 1; 200; 500;

Capacity: c ¼ 1000; 1200; 1500; 2000; 3000; 4000; 5000:

In order to obtain a better insight in the influence of the combination weight interval and bin capacity, wefix the number of items n 0 to 250 and also solve 20 instances of all combinations of the following values:

c ¼ 1000; 1200; 1500; 1600; 1700; 1800; 1900; 2000; 2500; 3000; 3500; 4000; 5000;

wm ¼ 1; 50; 100; 200; 250; 300; 350; 400; 450; 500:

Motivated by the existence of a cutting stock counterpart of the DBP, named the skiving stock problem[14], we extend the data set using the cutting stock data classes of [27] as extended in [7]. The classes aredefined by three parameters:

Number of items: n ¼ 50; 75; 100; 150; 250;

Average availablity for each item: �d ¼ 10; 50; 100;

Weight interval ½1; f �c�: f ¼ 0:25; 0:50; 0:75; 1:

The capacity of each bin c is 10000. As a consequence, we will solve 1440 randomly generated data in-stances, i.e. 20 instances for 72 classes.

5.1.2. Comparison with existing procedures

Table 1 compares the computation times of our procedure B&P with those obtained by the procedureLA of Labbe et al. [15] only for those classes of instances where one of the two procedures has an averageCPU time different from 0. We observe that the data classes of [15] are not a challenge for our branch-and-

1comparison between branch-and-price (B&P) and the enumeration procedure (LA) (computation times on a Dell optiplex G1m II 350MHz PC)

c n0

40 60 80 100

B&P LA B&P LA B&P LA B&P LA

100 0.00 0.08 0.00 2.75 0.00 28.52 (1) 0.01 1.81120 0.00 0.01 0.00 1.38 0.00 1.44 0.01 39.00 (1)150 0.00 0.01 0.00 1.70 0.00 0.09 0.01 1.53

120 0.00 2.09 0.00 0.08 0.00 19.33 (1) 0.00 22.93 (1)150 0.00 5.70 0.00 8.77 0.00 45.03 (2) 0.00 54.71 (1)200 0.00 0.05 0.00 23.94 (1) 0.00 28.85 (1) 0.00 0.19

150 0.00 0.01 0.00 0.01 0.00 0.05 0.00 0.32200 0.00 0.01 0.00 0.01 0.00 0.01 0.00 0.01300 0.00 0.03 0.00 0.13 0.02 30.14 (1) 0.04 68.76 (2)400 0.00 0.04 0.03 0.20 0.03 24.38 (1) 0.02 34.28 (1)500 0.00 0.02 0.00 0.02 0.00 0.10 0.00 0.30


price method and the currently available computing power. Given the difference in processor speed betweenthe computers, which is a factor 70–90, as mentioned earlier, and given that most of the computation timesfor B&P are not significantly different from 0, it is hard to draw conclusions with respect to the relativeperformance of both algorithms. However, older results of the same B&P algorithm performed on a slowerPC and reported in [19], indicate that B&P is not faster than LA on all classes of instances, but on most ofthem. Moreover, B&P always finds the optimal solution, in contrast to LA, which failed to do so for 14instances, within the imposed limit on the number of nodes in the branch-and-bound enumeration tree.The main reason why neither of the two algorithms is consistently better may be due to the fact thatLA uses more and different heuristics and upper bounds than B&P and, also, because the proceduresare tested on different instances of identical type. However, since B&P always finds the optimum and is fas-ter in most of the cases, it seems that branch-and-price is superior to branch-and-bound, based on combi-natorial bounds, for solving the DBP. The essential reason for this is the quality of the upper bound of theLP relaxation.

5.1.3. Investigation of the behaviour of the algorithm

In this section, we investigate the effect of the different problem characteristics on the computation time.Table 2 presents the computation times for the extended data sets of [15]. Detailed computational results,for n 0 greater than 100, can be found in Table A.1 of the Appendix A. All instances up to 250 items can besolved within the time limit of 15 minutes. We do not obtain a proven optimal solution for 4 out of 420instances with 500 items and observe high average computation times for some intervals, illustrating thelimits of our branch-and-price procedure. The classes with weight interval [500,999] seem to be the hardest.

Table 2DBP, computation times for the extended data classes of Labbe et al. [15]

c wm n 0

60 80 100 250 500

1000 1 0.01 0.06 0.08 2.39 9.67200 0.00 0.00 0.00 0.00 0.00500 0.00 0.00 0.00 0.00 0.00

1200 1 0.07 0.17 0.40 10.52 54.66200 0.01 0.02 0.05 0.30 1.65500 0.00 0.00 0.00 0.00 0.00

1500 1 0.12 0.15 0.37 13.14 48.03200 0.08 0.09 0.25 5.52 35.49500 0.00 0.01 0.03 0.14 0.38

2000 1 0.04 0.00 0.31 0.02 0.07200 0.04 0.19 0.21 9.87 151.54500 0.00 0.01 0.03 0.44 2.36

3000 1 0.00 0.00 0.00 0.00 0.01200 0.00 0.00 0.00 9.16 0.82 (1)500 0.00 0.15 0.36 26.76 168.50

4000 1 0.00 0.00 0.00 0.00 0.00200 0.00 0.00 0.00 0.03 0.46500 0.00 0.15 0.70 34.98 421.43

5000 1 0.00 0.00 0.00 0.00 0.01200 0.00 0.00 0.00 0.02 0.18500 0.00 0.18 0.01 29.13 101.63 (3)


The reason is that our branch-and-bound procedure for the subset sum problems of the fill bin heuristic andthe pricing problems of the column generation procedure cannot always find solutions in reasonable time.Some results in the literature confirm that these problems can be hard to solve using a branch-and-boundalgorithm. Regarding the subset sum problem, Pisinger and Toth [20] remark that branch-and-bound per-forms poorly on every instance for which there exist no solution that exactly fills the knapsack and thatdynamic programming is a better alternative. This happens more often for these instances, because ofthe absence of small items that are often required to exactly meet the bins capacity. They also observe thatstrongly correlated unbounded knapsack problems without small items are hard to solve for their algorithmMTU2 [20]. The pricing problem, although a bounded knapsack problem, which arises when the weightinterval is [500,999], corresponds to this class. Unfortunately, results for the bounded knapsack problemwithout small weights being solved with a branch-and-bound algorithm are not reported in the literature.However, Martello, Pisinger and Toth [17] mention that the branch-and-bound algorithm MT2 for 0–1knapsack problems, performs poorly on the so-called ‘‘uncorrelated similar weights instances’’, these areinstances where the weights are drawn in the interval [105,105 + 100]. Our knapsack problems are relatedto this class, since both do not have small items.

We further analyse the behaviour of the algorithm by investigating the influence of the different problemcharacteristics on the computation time, i.e. the number of items and the combination of the weight intervaland the bin capacity. It is obvious that the more items there are, the longer the computation time is. Hence,we focus on the combination of the weight interval and the bin capacity. To do so, we investigate the dataclasses with n 0 equal to 250. Table 3 summarizes the computation times for all combinations of the param-eter values, presented in Section 5.1.1. We see that there is a clear interaction between both parameters, e.g.for c = 1500, the hardest instances are those where wm equals 1 and the easiest where wm equals 500,whereas for c = 5000, the opposite seems to be true. Hence, we cannot investigate the effect of both param-eters separately. Therefore, we distinguish three groups of data classes based on the size of the bins, andinvestigate the effect of the lower limit wm for each group separately. The groups are:

TableDBP,

wm

150100150200250300350400450500

Small Bins ðSBÞ; or c ¼ 1000; 1200; 1500; 1600;

Medium BinsðMBÞ; or c ¼ 1700; 1800; 1900; 2000;

Large BinsðLBÞ; or c ¼ 2500; 3000; 3500; 4000; 5000:

Since the upper limit of the weight interval is fixed at 999, the groups can also be characterized by theratio of the upper limit divided by the bin capacity, indicating the relative size of the largest possible itemscompared to the bin capacity. For SB, this ratio is between 1 and 0.6, for MB between 0.6 and 0.4, and for

3computation times, n 0 = 250

c

1000 1200 1500 1700 2000 2500 3000 3500 4000 5000

2.39 10.52 13.14 4.06 0.02 0.01 0.00 0.01 0.00 0.000.05 4.61 8.46 1.53 1.24 0.00 0.01 0.00 0.00 0.000.00 2.32 8.98 4.06 0.08 0.01 0.01 0.01 0.01 0.000.00 1.34 7.32 7.03 0.22 0.04 0.06 0.01 0.02 0.010.00 0.30 5.52 10.89 9.87 7.04 9.16 0.03 0.03 0.020.00 0.01 2.74 6.64 13.31 4.19 0.19 12.76 0.08 0.040.00 0.00 2.06 6.64 9.33 3.17 11.05 0.10 0.15 0.050.00 0.00 1.50 6.04 5.31 7.86 24.66 7.29 13.39 0.120.00 0.00 1.64 3.38 0.81 11.39 14.88 27.28 27.98 23.830.00 0.00 0.52 1.30 0.96 14.64 53.44 13.93 35.53 14.710.00 0.00 0.14 0.25 0.44 21.66 26.76 52.47 34.98 29.13


LB smaller than 0.4. Figs. 1–3 present the average computation time (seconds) over 20 items for the threegroups for each value wm. The bold, line indicates the average over all bin capacities of the group. We ob-serve that for group SB, the easiest instances are those with a large lower limit on the item weights. This canbe explained by the reduction criteria that are very effective on these classes. As explained earlier, thosecriteria look for a pair of items for which the sum of the weights equals or exceeds the bin capacity. This

Fig. 2. DBP, computation times medium bins, n 0 = 250.

Fig. 1. DBP, computation times small bins, n 0 = 250.

Fig. 3. DBP, computation times large bins, n 0 = 250.

Table 4Performance of the components of the algorithm

Group Phase wm

1 50 100 150 200 250 300 350 400 450 500

SB RED (%) 3 18 24 25 26 45 49 50 50 50 53H (%) 31 26 9 0 4 1 3 0 0 1 1LP (%) 8 8 4 5 18 13 14 19 21 28 46B&P (%) 58 48 63 70 52 41 34 31 29 21 0

MB RED (%) 0 0 0 0 0 0 0 0 0 0 0H (%) 95 95 94 79 56 30 19 19 25 25 25LP (%) 0 0 0 0 0 0 0 0 0 20 75B&P (%) 5 5 6 21 44 70 81 81 74 55 0

LB RED (%) 0 0 0 0 0 0 0 0 0 0 0H (%) 100 100 100 100 98 98 97 90 81 63 49LP (%) 0 0 0 0 0 0 0 0 0 0 0B&P (%) 0 0 0 0 2 2 3 10 19 37 51


occurs more frequently if the average item weight is high compared to the bin capacity and only if the max-imum item weight is at least the half of the bin capacity. Hence, the algorithm must only solve reduced in-stances, with a number of items much less than 250, resulting in smaller computation times. This isillustrated in Table 4, presenting the performance of the different components of our algorithm for the threegroups of data classes. The rows have the following meaning:

RED: the percentage of instances that can be solved by reduction;H: the percentage of the instances for which the heuristic solution equals the best a priori upper bound;LP: the percentage of instances for which the heuristic solution equals the LP upper bound;

B&P: the number of instances for which the branch-and-price procedure must be called.

For the group MB, we see that the classes with a minimum weight between 250 and 350 are the hardestto solve. This can be explained by the good performance of the heuristics, if the lower limit of the weightinterval is low or high, as shown in Table 4. The a priori upper bounds and the heuristics perform very wellon instances with a small lower limit wm. Hence, an optimal solution can often be found without computingthe LP upper bound or calling the branch-and-price algorithm. This is clearly not the case if the lower limitis between 250 and 350. For a higher lower limit, the performances of the heuristics is better again andequals even 100% for wm = 500. As a result, for these instances, it is sufficient to compute the LP boundto obtain proven optimal solutions, if the a priori upper bounds fail to do so and the branch-and-price algo-rithm must not be called.

For the group LB, the computation time increases with the lower limit of the weight interval as shownin Fig. 3. The explanation is again the good performance of the heuristics and the a priori upperbounds for a relatively small lower limit wm, compared to the bin capacity, as illustrated in Table 4. More-over, if the lower limit is high, then the long computation times to solve the knapsack problems, as ex-plained earlier, aggravates the effect on the solution time. Detailed results can be found in Table A.2 ofthe Appendix A.

Table 5 presents the average computation times for the Skiving Stock instances for every data class char-acterized by the number of items n, the average demand for each item �d and the fraction of the capacity f

that provides the upper limit of the weight interval. All but one instance can be solved in short computationtimes. The detailed computational results, for n = 100, 150, 200, and 250, are presented in Table A.3 of the

Table 5Computation times of the skiving stock instances

�d f n

50 75 100 150 200 250

10 0.25 0.13 0.02 0.02 0.05 0.08 0.200.50 0.39 0.70 1.19 2.54 19.44 30.810.75 0.26 0.93 2.32 9.67 25.19 59.991.00 0.03 0.39 0.39 1.50 2.62 6.10

50 0.25 0.16 0.05 0.11 0.21 0.35 0.520.50 0.41 1.79 2.97 10.02 26.95 33.990.75 0.29 1.38 3.07 13.45 35.45 76.561.00 0.07 0.15 0.28 1.29 2.67 4.81

100 0.25 0.05 0.27 0.12 0.06 0.00 2.93 (1)0.50 0.59 1.56 2.75 3.86 0.03 60.280.75 0.38 1.17 3.36 14.61 22.88 93.531.00 0.03 0.09 0.41 4.18 2.74 3.60


Appendix A. The reduction criteria are less effective and for 69% of the instances the branch-and-price algo-rithm must be called to obtain proven optimal solutions.

5.2. The maximum cardinality bin packing problem

5.2.1. Data sets

We have tested our branch-and-price algorithm B&P on the same data classes as the algorithm of Labbeet al. [16], called LA, i.e. on the 180 combinations of three parameters:

Number of bins: m ¼ 2; 3; 5; 10; 15; 20;

Capacity: c ¼ 100; 120; 150; 200; 300; 400; 500; 600; 700; 800;


Items are generated as long as the sum of the weights of the items is smaller than the number of bins mul-tiplied by the capacity (=m*c). For each combination of the three parameters, 10 instances are generated. Inaddition, we extend the data set of [16] by enlarging the weight intervals and multiply the capacity by afactor of 10. Moreover, it is well-known that the computation time for packing problems is heavily depend-ant on the number of different items of an instance. Therefore, rather than fixing the number of bins m, wewould like to fix the expected number of generated items, denoted as E(n 0). This number, however, is notinput for generating the instances, but is implicitly determined by the number m of bins and the bin capacityc. As the item weights are uniformly distributed on the weight interval [wm, 999], the expected item weightequals (wm + 999)/2, and, hence, the expected number of generated items, is equal to E(n 0) = 2cm/(wm + 999). Given a desired number of expected items �n, then the number of bins m must equal�nðwm þ 999Þ=2c. We solve instances for all combinations of the following parameter values:

Desired number of items: �n ¼ 100; 150; 200; 250; 300; 350; 400; 450; 500;

Capacity: c ¼ 1000; 1200; 1500; 2000; 3000; 4000; 5000; 6000; 7000; 8000;


In addition, we would like to investigate the performance of the algorithm for different combinations ofweight interval and bin capacity, as we did for the DBP. Therefore, we fix �n equal to 250 and we execute theexperiments with the following additional parameter values:

TableCBP,

wm

1

20

50


wm ¼ 50; 100; 150; 250; 300; 350; 400; 450;

c ¼ 1600; 1700; 1800; 1900; 2500; 3500:

5.2.2. Comparison with existing procedure

Table 6 compares the algorithm LA of Labbe et al. [16] with the branch-and-price algorithm B&P for thethree different weight intervals, only for those types of instances where the average CPU time is significantlydifferent from 0 for one of the two algorithms. B&P clearly outperforms LA, because all instances could besolved to a proven optimal solution, whereas LA fails to do so for 30 instances. We remark that there is asubstantial difference in the processor speeds between the computers on which the tests are performed.Therefore, we refer again to [19], reporting older results, illustrating that B&P outperforms LA.

5.2.3. Investigation of the behaviour of the algorithm

Table 7 presents the results for the extended data classes. Our procedure was not able to solve all in-stances within 15 minutes. For the data classes with the weight interval [500,999], we are not able to solve23 instances out of 200 for �n ¼ 300, and a relatively high bin capacity (c = 5000,6000,7000). We encoun-tered similar difficulties as in the case of the DBP, namely our branch-and-bound method to solve the knap-sack problems and the subset sum problems is not always able to provide solutions in reasonable time,because of the absence of items with small weights. Therefore, we do not solve these instances for highernumbers of desired items. On the other hand, for c = 8000, we see that these instances can still be solvedin reasonable time for �n ¼ 300, because 500 is relatively smaller compared to 8000 than to 5000. However,

6comparison with Labbe et al. [16] (computation times)

c m

5 10 15 20

B&P LA B&P LA B&P LA B&P LA

100 0.00 0.24 0.00 0.39 0.00 0.58 0.00 0.67120 0.00 0.04 0.00 0.29 0.00 0.56 0.00 0.61150 0.00 0.21 0.00 0.11 0.00 1.06 0.00 0.09200 0.00 0.08 0.00 0.07 0.00 0.03 0.00 0.03

100 0.00 0.13 0.00 0.32 0.00 0.27 0.00 0.63120 0.00 0.13 0.00 0.38 0.00 0.57 0.00 1.00150 0.00 0.19 0.00 0.41 0.00 0.48 0.00 3.66200 0.00 0.07 0.00 0.08 0.00 0.03 0.00 2.85300 0.00 0.01 0.00 0.01 0.00 0.03 0.00 0.06400 0.00 0.01 0.00 0.02 0.00 0.05 0.00 0.07500 0.00 0.01 0.00 0.02 0.00 0.05 0.00 0.11600 0.00 0.00 0.00 0.02 0.00 0.04 0.00 0.10700 0.00 0.01 0.00 0.02 0.00 0.07 0.00 0.13800 0.00 0.08 0.00 0.02 0.00 0.06 0.00 0.17

120 0.00 0.07 0.00 0.14 0.00 0.16 0.00 0.22150 0.0.0 0.28 0.00 0.17 0.00 0.40 0.00 0.50200 0.00 0.06 0.00 0.41 0.00 192.17 (3) 0.01 177.05 (2)300 0.00 0.05 0.01 41.72 (1) 0.04 258.54 (3) 0.07 268.14 (4)400 0.00 0.02 0.00 3.51 0.04 202.02 (3) 0.10 360.65 (5)500 0.00 0.03 0.00 0.10 0.00 0.63 0.10 133.00 (5)600 0.00 0.03 0.00 0.35 0.00 4.83 0.04 67.05 (1)700 0.00 0.05 0.00 0.14 0.00 9.30 0.04 745.19 (3)800 0.00 0.04 0.01 1.17 0.00 185.36 0.00 141.23

Table 7CBP, computation times for the extended data classes

E(n 0) wm c

1000 1200 1500 2000 3000 4000 5000 6000 7000 8000

100 1 0.07 0.14 0.27 0.00 0.00 0.00 0.00 0.00 0.00 0.00200 0.05 0.07 0.38 0.07 0.00 0.00 0.00 0.00 0.00 0.00500 0.00 0.00 0.03 0.51 1.40 0.62 1.47 0.57 0.01 0.01

150 1 0.13 1.13 2.32 0.00 0.00 0.00 0.00 0.00 0.00 0.00200 0.08 0.13 2.19 1.65 0.00 0.01 0.01 0.00 0.00 0.00500 0.00 0.01 0.08 4.75 7.99 13.86 10.91 10.25 0.25 0.68

200 1 0.49 2.99 6.04 0.00 0.00 0.00 0.00 0.00 0.00 0.00200 0.20 0.29 6.14 3.30 0.00 0.00 0.01 0.00 0.00 0.00500 0.00 0.06 0.22 6.13 24.31 47.76 41.17 23.90 0.78 9.70

300 1 1.33 7.18 15.83 10.72 0.00 0.01 0.00 0.00 0.00 0.00200 0.48 0.58 27.44 43.77 39.83 0.01 0.01 0.00 0.06 0.00500 0.39 0.10 0.41 16.87 71.72 239.57 326.60 (9) 115.25 (7) 16.67 (7) 7.41

350 1 2.09 29.26 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00200 0.55 1.44 41.19 86.64 94.07 0.02 0.01 0.00 0.00 0.00500 0.00 0.14 0.63 27.74 117.93 318.08 99.57 (1)

400 1 3.30 47.16 52.35 0.00 0.00 0.00 0.00 0.00 0.00 0.00200 0.81 1.57 68.65 139.05 0.08 0.04 0.03 0.01 0.01 0.01500 0.00 0.16 0.77 39.51 165.01 400.89

450 1 8.17 46.46 128.59 35.19 0.01 0.00 0.01 0.00 0.00 0.00200 1.02 2.30 88.80 207.47 0.08 (1) 0.06 0.06 0.04 0.04 0.04500 0.00 0.20 0.70 50.71 237.43 578.43

500 1 13.22 64.94 71.68 7.66 0.01 0.00 0.00 0.00 0.00 0.01200 1.60 1.65 127.60 374.65 0.43 (1) 0.13 0.20 0.04 0.03 0.03500 0.00 0.22 1.11 58.09 250.36 693.70 (3)

Table 8Computation times for E(n 0) = 250

c wm

1 50 100 150 200 250 300 350 400 450 500

1000 1.73 1.11 0.40 0.47 0.34 0.21 0.14 0.12 0.05 0.05 0.001200 1.94 4.10 1.84 2.44 0.84 0.47 0.41 0.19 0.19 0.12 0.061500 11.79 14.07 26.00 22.04 14.91 10.64 8.95 (1) 5.56 (1) 1.05 0.69 0.311600 4.76 6.96 34.99 34.48 23.99 17.11 10.72 13.11 2.46 1.83 0.821700 0.00 3.33 15.74 22.68 28.37 22.06 16.79 15.74 9.18 3.95 1.681800 0.00 0.00 0.00 5.82 31.36 23.94 22.37 17.68 13.03 7.19 3.511900 6.18 1.71 9.26 20.45 9.12 21.57 23.29 22.64 21.85 12.87 7.952000 0.00 0.10 0.08 19.92 15.45 18.07 21.22 18.47 19.12 17.53 13.422500 0.00 0.00 0.00 0.00 17.32 20.13 23.18 11.35 18.67 34.03 31.213000 0.00 0.00 0.00 13.42 0.00 0.01 18.65 53.59 39.81 70.57 36.353500 0.00 0.00 0.00 0.00 0.01 0.02 11.70 34.27 33.25 89.32 75.724000 0.00 0.00 0.00 0.00 0.00 0.01 0.04 13.79 35.02 149.68 98.785000 0.00 0.00 0.00 0.01 0.00 0.01 0.06 0.13 21.89 74.04 268.556000 0.00 0.00 0.00 0.00 0.00 0.02 0.06 0.20 0.26 0.71 204.047000 0.00 0.00 0.00 0.01 0.00 0.00 0.03 0.03 0.24 10.47 50.408000 0.00 0.00 0.00 0.00 0.01 0.00 0.04 0.16 0.52 2.09 6.25



for �n ¼ 350, we see that one instance cannot be solved within 900 seconds, and for higher numbers of de-sired items, none of the instances could be solved within the time limit.

We further investigate the influence of the combination of the weight interval and the bin capacity on thesolution time. For this reason, we fix the desired number of items equal to 250. Table 8 presents the com-putational results. As for the DBP, we observe a clear interaction between weight interval and bin capacityand, hence, we use the same division in small, medium and large bins. Figs. 4–6 present the computationtimes graphically.

Fig. 4. CBP, computation times small bins, n 0 = 250.

Fig. 6. CBP, computation times large bins, n 0 = 250.

Fig. 5. CBP, computation times medium bins, n 0 = 250.

Table 9CBP, Performance of the components of the algorithm

wm

1 50 100 150 200 250 300 350 400 450 500

SB H (%) 56 36 9 8 3 5 3 1 5 4 34LP (%) 26 33 40 33 43 36 41 50 75 73 45B&P (%) 18 31 51 59 54 59 55 48 20 23 21

MB H (%) 99 96 85 61 44 18 5 0 0 0 0LP (%) 0 0 0 0 0 0 0 0 0 3 0B&P (%) 1 4 15 39 56 82 95 100 100 97 100

LB H (%) 100 100 100 99 98 97 94 87 82 53 44LP (%) 0 0 0 0 0 0 0 0 0 0 0B&P (%) 0 0 0 1 2 3 6 13 18 47 56


For the group SB, we observe that the hardest instances are those with a relatively small lower limitwm, i.e. 100–200. For smaller lower limits, we see that the heuristics and a priori upper bounds performwell, and only very few times the B&P algorithm must be called, as illustrated in Table 9, where the rowheadings have the same meaning as in Table 5. It is well-known from the BPP literature that the FFDheuristic performs poorer, in absence of small items. If the lower limit becomes higher (P400), the per-formance of the heuristics is better again, because the instances of these classes are easy. Indeed, forc = 1000 and wm = 500, at most one item can be packed in a bin, except if the instance contains two itemswith a weight equal to 500. Hence, it is most likely that the FFD heuristic discovers the optimal solution.For smaller lower limits and higher bin capacity, the instances will be somewhat harder, but in general theFFD will be able to pack a number of items equal to the upper bound. Unfortunately, the a priori upperbounds do not perform well for the group SB, and therefore the computational more intensive LP boundmust frequently be computed, such that the heuristics can find a solution that packs the bZCMP

LP c smallestitems in m bins. For the group MB and LB, we also observe the excellent performance of the heuristicsfor a low wm. In addition, the best a priori upper bound often equals the optimal solution, implying thatthe LP bound and the branch-and-price algorithm must exceptionally be called. For larger values of thelower limit, the branch-and-price algorithm is required to solve almost all instances for the group MB, butthe required CPU time decreases. For the group LB, we observe that the percentage of the instances forwhich the B&P algorithm must be called, increases, if the lower limit increases. In addition, the poorerperformance of the knapsack solver on these instances results in very high computation times forwm = 500.

6. Conclusions

We have described and extensively tested a new formulation for the dual bin packing problem andthe maximum cardinality bin packing problem. The LP relaxation of this formulation can be found usingthe hybrid simplex method/subgradient optimization procedure. The computational results show that theupper bound provided by the LP relaxation is tight, because, for all instances we could solve, this bound isequal to the optimal solution. Next, we have developed a branch-and-price algorithm for both problems.Both algorithms outperform the enumeration algorithms of [15,16]. The main reason for this is the qualityof the upper bound of the LP relaxation. The computational results identify difficult data classes and illus-trate the limits of our branch-and-price algorithm and our procedure to solve the knapsack problems.


Future research will be focussed on improvement of our knapsack solver and on the transfer of the ideasdeveloped in this paper to related problems.

Appendix A. Detailed computational results

In this appendix, we give more details about the performance of the algorithms. The following columnheadings are used in the tables:

tIP average CPU time in secondsred number of instances solved by reduction criteriaUBap number of times the best a priori upper bound equals the optimal solutionUBLP number times the LP bound equals the optimal solutionH1 number of times the first heuristic equals the optimal solution

Table A.1DBP, detailed computational results for the extended data classes

n0 c wm tIP red UBap H1 H2 nLP UBLP tLP nBP mst sp br

100 1000 1 0.08 2 4 9 1 16 20 0.10 8 7.75 67.44 3.001200 1 0.40 0 14 4 0 16 20 0.26 16 19.56 115.06 8.751200 200 0.05 3 6 14 0 15 20 0.06 3 5.73 56.80 1.331500 1 0.37 0 20 6 6 8 20 0.18 8 25.50 115.12 15.381500 200 0.25 0 19 3 8 10 20 0.18 9 23.70 121.70 12.891500 500 0.03 1 3 19 0 17 20 0.04 0 3.94 39.12 0.002000 1 0.31 0 20 14 4 2 20 0.22 2 45.00 239.50 22.502000 200 0.21 0 20 7 10 3 20 0.20 3 29.67 160.33 18.673000 500 0.36 0 20 0 18 2 20 0.30 2 48.50 332.00 22.504000 500 0.70 0 20 0 18 2 20 0.41 2 46.00 425.50 14.50

250 1000 1 2.39 2 4 5 0 18 20 2.33 13 14.94 182.56 5.621200 1 10.52 0 16 1 0 20 20 2.88 19 44.55 253.15 30.471200 200 0.30 1 1 13 0 19 20 0.31 6 5.74 87.47 0.831500 1 13.14 0 20 8 1 11 20 0.68 11 46.00 205.55 33.361500 200 5.52 0 18 0 3 18 20 0.67 17 43.44 192.61 33.241500 500 0.14 2 3 17 1 17 20 0.16 0 3.94 38.41 0.002000 200 9.87 0 20 0 14 6 20 1.55 6 68.00 318.83 53.003000 200 .9.16 0 20 0 19 1 20 3.46 1 115.00 1020.00 45.003000 500 26.76 0 20 0 10 10 20 3.21 10 95.90 654.10 56.204000 500 34.98 0 20 0 15 5 20 4.85 5 103.40 883.80 43.405000 500 29.13 0 20 0 18 2 20 6.73 2 117.50 1312.50 34.00

500 1000 1 9.67 2 3 4 0 18 20 9.82 14 14.22 219.61 4.501200 1 54.66 0 16 0 0 20 20 11.88 20 67.15 384.00 49.751200 200 1.65 1 1 11 0 19 20 1.67 8 7.26 145.05 2.001500 1 48.03 0 20 5 4 11 20 2.61 11 47.27 223.27 37.551500 200 35.49 0 19 0 0 20 20 2.09 20 63.35 311.65 48.351500 500 0.38 3 3 15 2 17 20 0.44 0 3.35 43.47 0.002000 200 151.54 0 20 0 9 11 20 8.23 11 112.45 616.36 87.093000 200 0.82 (1) 0 19 0 19 0 193000 500 168.50 0 20 0 9 11 20 10.71 11 132.45 929.64 90.094000 500 421.43 0 20 0 8 12 20 15.46 12 153.33 1352.42 84.505000 500 101.63 (3) 0 17 0 15 2 17 22.69 2 135.00 1440.50 68.50


H2 number of times the second heuristic equals the optimal solution, if the first one fails to do sonLP number of times the computation of the LP relaxation was necessary, because the a priori upper

bounds differ from the heuristic solutionstLP average time to find the LP relaxation over nLPnBP number of times the branch-and-price algorithm has to be called, because the heuristic solutions

differ from the LP boundmst average number of master problems solved over nLPsp average number of pricing problems solved over nLPbr average number of branches added to the master problem to find an integer solution over nBP

Table A.1 presents the details for the extended data class of [15]. We restrict the presentation to the dataclasses for which the LP bound must be computed for at least one instance or if the computation time issignificantly different from 0. Table A.2 gives the results for n 0 = 250. Table A.3 presents the detailed resultsfor the SSP instances for n greater or equal to 100. For smaller instances the computation time is always lessthan a second.

The remaining Tables present details for the CBP instances. Table A.4.1 and A.4.2 give the results for theextended data classes for �n greater than or equal to 200, and only if the LP bound is required or the dataclass contains unsolved instances.

Table A.2DBP, detailed computational results, for n = 250, large, medium, small bins

Group wm tIP red UBap H1 H2 nLP UBLP tLP nBP mst sp br

SB 1 7.30 2 60 24 7 53 80 1.74 47 34.56 191.69 23.9350 5.58 14 68 15 12 45 80 1.01 39 38.48 201.14 25.30100 4.96 19 66 5 5 54 80 0.80 51 29.09 162.02 18.80150 4.40 20 62 4 0 60 80 0.75 56 23.61 132.40 15.87200 3.44 21 58 13 4 56 80 0.50 42 25.59 136.55 18.10250 2.33 36 65 4 7 43 80 0.56 33 21.09 114.69 15.38300 1.91 40 57 2 11 38 80 1.03 27 16.08 84.78 12.98350 1.55 40 50 6 9 40 80 1.12 25 11.88 68.45 8.39400 1.90 40 41 8 9 40 80 1.74 23 8.90 56.81 4.92450 0.38 40 43 7 16 39 80 0.35 17 4.90 36.45 2.80500 0.09 42 43 37 1 37 80 0.10 0 1.91 20.27 0.00

MB 1 2.66 0 80 49 27 4 80 2.18 4 53.83 370.92 27.2550 1.93 0 80 46 30 4 80 1.32 4 59.50 345.13 36.25100 2.47 0 80 32 43 5 80 0.59 5 43.46 220.67 27.88150 4.09 0 80 7 56 17 80 0.71 17 51.65 244.20 36.99200 7.15 0 80 0 45 35 80 1.03 35 61.12 298.12 45.46250 11.58 0 80 0 24 56 80 1.32 56 70.08 360.94 50.09300 10.21 0 80 0 15 65 80 1.31 65 63.22 318.21 46.35350 9.61 0 64 0 15 65 80 2.41 65 65.78 346.70 43.85400 4.52 0 30 0 21 60 80 0.95 59 34.44 191.38 23.95450 1.56 0 20 5 31 60 80 0.47 44 14.15 85.48 11.52500 0.33 0 20 54 26 60 80 0.22 0 2.83 35.18 0.00

LB 200 3.26 0 100 43 55 2 100 1.19 2 47.40 382.80 20.40250 3.45 0 100 28 70 2 100 1.73 2 45.20 423.00 19.60300 2.90 0 100 14 83 3 100 1.25 3 39.70 283.60 22.10350 10.66 0 100 7 83 10 100 2.88 10 84.61 699.61 39.39400 21.07 0 100 2 79 19 100 4.61 19 98.92 928.51 45.46450 26.45 0 100 0 63 37 100 3.95 37 98.50 845.05 45.78500 33.00 0 100 0 49 51 100 3.79 51 95.96 789.09 46.56

Table A.3Computational results of the skiving stock instances

n d f tIP red UBap H1 H2 nLP tLP nBP mst sp br

100 10 0.25 0.02 0 20 13 7 0 0.15 0 4.97 40.68 0.150.50 1.19 0 20 0 5 15 0.40 15 16.93 112.78 6.410.75 2.32 0 7 0 0 20 1.76 20 24.65 181.34 9.221.00 0.39 2 2 0 0 18 0.51 18 8.81 81.19 1.85

50 0.25 0.11 0 20 0 18 2 0.45 2 8.41 77.59 1.420.50 2.97 0 19 0 2 18 0.88 18 32.08 247.37 11.690.75 3.07 0 0 0 0 20 2.91 20 23.30 192.37 7.581.00 0.28 0 0 0 0 20 0.40 20 8.17 71.42 1.83

100 0.25 0.12 0 20 0 18 2 0.42 2 5.08 35.71 0.910.50 2.75 0 20 0 0 20 0.80 20 26.05 206.14 10.800.75 3.36 0 0 0 0 20 3.23 20 21.05 186.86 6.641.00 0.41 1 1 0 0 19 0.52 19 15.16 101.10 2.67

150 10 0.25 0.05 0 20 13 7 0 0.00 0 0.00 0.00 0.000.50 2.54 0 20 0 9 11 0.73 11 17.18 120.91 7.550.75 9.67 0 11 0 0 20 7.04 20 36.01 286.85 16.531.00 1.50 0 0 0 0 20 1.83 20 9.40 105.34 1.48

50 0.25 0.21 0 20 0 20 0 1.83 0 9.40 105.34 1.480.50 10.02 0 20 0 1 19 1.31 19 39.23 287.49 16.290.75 13.45 0 1 0 0 20 12.29 20 32.06 299.42 14.411.00 1.29 3 3 0 0 17 2.22 17 9.53 104.91 1.67

100 0.25 0.06 0 20 3 17 0 2.22 0 9.53 104.91 1.670.50 3.86 0 17 1 16 6 5.84 3 105.59 1076.48 13.220.75 14.61 0 13 0 14 7 13.85 6 264.51 1526.21 44.201.00 4.18 0 15 0 6 16 5.63 14 49.91 570.26 7.51

200 10 0.25 0.08 0 20 13 7 0 5.63 0 49.91 570.26 7.510.50 19.44 0 20 0 5 15 1.57 15 38.99 335.28 17.030.75 25.19 0 10 0 0 20 17.69 20 48.25 404.61 26.001.00 2.62 1 1 0 1 19 3.55 18 11.75 140.56 3.33

50 0.25 0.35 0 20 0 20 0 3.55 0 11.75 140.56 0.330.50 26.95 0 20 0 1 19 1.79 19 43.46 345.45 16.700.75 35.45 0 1 0 0 20 30.95 20 39.22 394.32 19.841.00 2.67 2 2 0 0 18 4.65 18 8.68 140.18 1.38

100 0.25 0.00 0 20 6 14 0 4.65 0 8.68 140.18 1.380.50 0.03 0 20 0 20 0 4.65 0 8.68 140.18 1.380.75 22.88 0 16 2 17 5 88.73 1 253.34 3926.24 49.381.00 2.74 0 18 0 14 7 17.47 6 134.05 2103.03 20.90

250 10 0.25 0.20 0 20 10 10 0 17.47 0 134.05 2103.03 20.900.50 30.81 0 20 0 5 15 2.95 15 43.34 378.80 20.990.75 59.99 0 9 0 0 20 38.73 20 55.87 477.89 32.601.00 6.10 1 1 0 0 19 8.30 19 11.99 161.89 3.45

50 0.25 0.52 0 20 0 20 0 8.30 0 11.99 161.89 3.450.50 33.99 0 19 0 1 19 3.39 19 33.79 282.78 15.390.75 76.56 0 0 0 0 20 71.46 20 43.19 482.74 23.771.00 4.81 1 1 0 1 19 8.33 18 11.75 150.57 3.65

100 0.25 2.93 (1) 0 19 2 16 1 9.26 1 68.75 400.57 4.650.50 60.28 0 18 1 3 16 4.62 16 81.05 552.04 25.790.75 93.53 0 0 0 0 20 82.70 20 64.05 510.35 37.591.00 3.60 1 9 0 2 17 7.68 17 28.24 473.67 6.03


Table A.4.1CBP, computational results for the extended data class, �n ¼ 200; 300; 350

E(n 0) c wm tIP UBap H1 H2 nLP UBLP tLP nBP sp mst br

200 1000 1 0.49 2 19 0 19 20 0.03 1 153.05 8.42 98.001000 200 0.20 0 17 0 20 20 0.09 3 146.35 8.45 114.331200 1 2.99 13 16 0 11 20 0.36 4 271.45 28.73 79.501200 200 0.29 1 19 0 19 20 0.05 1 159.00 9.00 98.001200 500 0.06 0 20 0 20 20 0.00 0 72.10 5.00 0.001500 1 6.04 20 14 0 6 20 0.74 6 410.00 57.67 42.671500 200 6.14 20 0 0 20 20 0.51 20 314.50 51.10 78.201500 500 0.22 3 20 0 17 20 0.00 0 168.76 7.88 0.002000 200 3.30 20 0 16 4 20 0.62 4 470.00 77.75 59.252000 500 6.13 20 0 0 20 20 1.23 20 302.20 44.25 73.753000 500 24.31 20 0 3 17 20 1.71 17 632.94 87.88 49.354000 500 47.76 20 0 6 14 20 7.02 14 807.64 91.21 37.145000 500 41.17 20 0 13 7 20 16.26 7 913.29 92.29 29.006000 500 23.90 20 0 18 2 20 73.63 2 1101.00 89.50 24.507000 500 0.78 20 0 20 0 20 0.00 0 0.00 0.00 0.008000 500 9.70 20 0 20 0 20 0.00 0 0.00 0.00 0.00

300 1000 1 1.33 1 18 0 19 20 0.36 2 238.00 10.11 146.501000 200 0.48 1 17 0 19 20 0.20 3 211.32 9.58 160.331000 500 0.39 0 20 0 20 20 0.00 0 172.00 9.00 0.001200 1 7.18 15 15 0 10 20 1.09 5 317.80 28.60 95.201200 200 0.58 2 19 0 18 20 0.17 1 228.67 9.50 133.001200 500 0.10 1 20 0 19 20 0.00 0 83.84 4.89 0.001500 1 15.83 20 15 0 5 20 2.15 5 531.20 74.20 69.401500 200 27.44 20 0 0 20 20 1.42 20 457.60 67.60 117.451500 500 0.41 5 20 0 15 20 0.00 0 226.33 8.40 0.002000 1 10.72 20 19 0 1 20 3.84 1 978.00 127.00 76.002000 200 43.77 20 0 9 11 20 2.04 11 653.55 104.73 89.002000 500 16.87 20 0 0 20 20 2.92 20 394.20 52.00 111.153000 200 39.83 20 0 19 1 20 12.79 1 1887.00 174.00 59.003000 500 71.72 20 0 3 17 20 3.79 17 800.06 112.35 74.064000 500 239.57 20 0 1 19 20 24.71 19 1124.74 125.00 56.165000 500 326.60 (9) 11 0 4 7 11 155.56 7 1277.86 120.00 44.146000 500 115.25(7) 13 0 11 2 13 171.34 2 1578.50 130.50 37.007000 500 16.67(7) 13 0 13 0 13 0.00 0 0.00 0.00 0.008000 500 7.41 20 0 20 0 20 0.00 0 0.00 0.00 0.00

350 1000 1 2.09 1 18 0 19 20 0.81 2 274.00 10.84 158.501000 200 0.55 0 18 0 20 20 0.14 2 213.30 7.90 184.001200 1 29.26 14 12 0 14 20 2.06 8 460.14 47.36 134.501200 200 1.44 1 15 0 19 20 0.91 5 345.63 14.05 160.001200 500 0.14 1 20 0 19 20 0.00 0 93.79 4.74 0.001500 200 41.19 20 0 0 20 20 2.03 20 517.45 70.55 137.951500 500 0.63 3 20 0 17 20 0.00 0 239.47 7.65 0.002000 200 86.64 20 0 7 13 20 2.71 13 760.54 117.15 104.002000 500 27.74 20 0 0 20 20 4.73 20 461.50 58.15 129.803000 200 94.07 20 0 17 3 20 8.18 3 1351.33 141.33 69.673000 500 117.93 20 0 4 16 20 7.53 16 894.12 124.62 87.064000 500 318.08 20 0 2 18 20 19.83 18 1303.11 142.78 65.17


Table A.4.2CBP, computational results for the extended data class, �n ¼ 400; 450; 500

E(n0) c wm tIP UBap H1 H2 nLP UBLP tLP nBP sp mst br

400 1000 1 3.30 1 20 0 19 20 0.00 0 285.63 10.47 0.001000 200 0.81 1 17 0 19 20 0.25 3 274.37 10.00 207.001200 1 47.16 12 14 0 14 20 1.97 6 484.64 46.50 162.831200 200 1.57 1 18 0 20 20 0.31 2 332.35 11.80 191.001200 500 0.16 1 20 0 19 20 0.00 0 94.26 4.63 0.001500 1 52.35 20 17 0 3 20 4.96 3 908.00 122.33 118.331500 200 68.65 19 0 0 20 20 5.91 20 625.25 76.45 156.701500 500 0.77 3 20 0 17 20 0.00 0 240.18 7.59 0..002000 200 139.05 20 0 8 12 20 3.97 12 871.50 127.42 118.922000 500 39.51 20 0 0 20 20 6.17 20 508.05 61.05 147.853000 500 165.01 20 0 2 18 20 6.94 18 927.44 129.00 99.064000 500 400.89 20 0 3 17 20 23.10 17 1334.24 155.41 74.18

450 1000 1 8.17 1 17 0 19 20 2.45 3 430.63 14.47 200.331000 200 1.02 0 18 0 20 20 0.29 2 271.90 10.00 235.001200 1 46.46 13 15 0 12 20 3.32 5 528.50 48.58 183.601200 200 2.30 4 20 0 16 20 0.00 0 329.62 11.12 0.001200 500 0.20 0 20 0 20 20 0.00 0 99.65 4.80 0.001500 1 128.59 20 15 0 5 20 6.44 5 1033.80 132.40 135.001500 200 88.80 20 0 0 20 20 3.82 20 636.85 78.70 175.701500 500 0.70 7 20 0 13 20 0.00 0 263.77 7.85 0.002000 1 35.19 20 18 1 1 20 11.04 1 1389.00 159.00 112.002000 200 207.47 20 0 6 14 20 4.75 14 944.29 131.86 134.002000 500 50.71 20 0 0 20 20 7.56 20 535.20 63.90 166.153000 200 0.08 (1) 19 0 19 0 19 0.00 0 0.00 0.00 0.00

500 1000 1 13.22 1 15 0 20 20 4.73 5 478.45 17.40 240.201000 200 1.60 0 18 0 20 20 0.52 2 316.25 10.50 258.001200 1 64.94 17 13 0 10 20 4.39 7 640.30 58.10 176.861200 200 1.65 1 19 0 19 20 0.35 1 326.00 11.00 208.001200 500 0.22 0 20 0 20 20 0.00 0 93.90 4.20 0.001500 1 71.68 20 17 1 2 20 9.17 2 1255.50 159.50 165.501500 200 127.60 19 0 0 20 20 4.87 20 740.40 84.80 194.901500 500 1.11 20 0 17 20 0.00 0 282.35 7.59 0.002000 1 7.66 20 16 2 2 20 20.10 2 462.00 33.00 40.002000 200 374.65 20 0 2 18 20 5.85 18 996.33 136.33 148.722000 500 58.09 20 0 0 20 20 8.26 20 557.60 65.85 183.803000 200 0.43 (1) 19 0 19 0 19 0.00 0 0.00 0.00 0.00


References

[1] J.L. Bruno, P.J. Downey, Probabilistic bounds for dual bin packing, Acta Informatica 22 (1985) 333–345.[2] V. Chvatal, Linear Programming, W.H. Freeman and Co, New York, 1983.[3] E.G. Coffman Jr., J.Y.-T. Leung, D.W. Ting, Bin packing: Maximizing the number of pieces packed, Acta Informatica 9 (1978)

263–271.[4] Z. Degraeve, L. Schrage, Should we use a portable generator in an emergency? Research Report, Department of Applied

Economic Sciences, K.U. Leuven, Belgium, 1997.[5] Z. Degraeve, L. Schrage, Optimal integer solutions to industrial cutting stock problems, INFORMS Journal on Computing 11

(1999) 406–419.[6] Z. Degraeve, M. Peeters, Solving the linear programming relaxation of cutting and packing problems: A hybrid simplex method/

subgradient optimization procedure, OR0017, Departement Toegepaste Economische Wetenschappen, K.U. Leuven, 2000.


[7] Z. Degraeve, M. Peeters, Optimal integer solutions to industrial cutting stock problems, Part 2: Benchmark results, INFORMSJournal on Computing 15 (2003) 58–81.

[8] J. Desrosiers, F. Soumis, A column generation approach to the urban transit crew scheduling problem, Transportation Science 23(1989) 1–12.

[9] J. Desrosiers, F. Soumis, M. Desrochers, Routing with time windows by column generation, Networks 14 (1984) 545–565.[10] J. Dongarra, Performance of various computers using standard linear equations software, Computer Science Technical Report,

CS-89-85, Computer Science Department, University of Tennessee, 2003.[11] A.M. Geoffrion, Lagragian relaxation for integer programming, Mathematical Programming Study 2 (1974) 82–114.[12] P.C. Gilmore, R.E. Gomory, A linear programming approach to the cutting stock-problem, Operations Research 9 (1961) 849–

859.[13] P.C. Gilmore, R.E. Gomory, A linear programming approach to the cutting stock problem—Part II, Operations Research 11

(1963) 863–888.[14] M.P. Johnson, C. Rennick, E. Zak, Skiving addition to the cutting stock problem in the paper industry, SIAM Review 39 (1997)

472–483.[15] M. Labbe, G. Laporte, S. Martello, An exact algorithm for the dual bin packing problem, Operations Research Letters 17 (1995)

9–18.[16] M. Labbe, G. Laporte, S. Martello, Upper bounds and algorithms for the maximum cardinality bin packing problem, Les Cahiers

du GERAD, G-97-05, 1997.[17] S. Martello, D. Pisinger, P. Toth, Dynamic programming and strong bounds for the 0–1 knapsack problem, Management Science

45 (1999) 414–423.[18] S. Martello, P. Toth, in: Knapsack Problems: Algorithms and Computer ImplementationsWiley Interscience Series in Discrete

Mathematics and Optimization, John Wiley & Sons, Chichester, UK, 1990.[19] M. Peeters, Cutting and packing: New problems and algorithms, PhD thesis, Departement of Applied Economics, K.U. Leuven,

2002.[20] D. Pisinger, P. Toth, in: D.-Z. Du, P. Pardalos (Eds.), Knapsack Problems, Handbook of Combinatorial Optimization, 1, Kluwer

Academic Publishers, Boston, MA, 1998, pp. 299–428.[21] W.T. Rhee, M. Talagrand, Dual bin packing with items of random sizes, Mathematical Programming 58 (1993) 229–242.[22] M. Savelsbergh, A branch-and-price algorithm for the generalized assignment problem, Operations Research 45 (1997) 831–841.[23] L. Schrage, Lindo: Optimization Software for Linear Programming, Lindo Systems Inc., Chicago, IL, 1995.[24] P.H. Vance, Branch-and-price algorithms for the one-dimensional cutting stock problem, Computational Optimization and

Applications 9 (1998) 212–228.[25] F. Vanderbeck, Computational study of a column generation algorithm for bin packing and cutting stock problems, Mathematical

Programming 86 (Series A) (1999) 565–594.[26] F. Vanderbeck, L.A. Wolsey, An exact algorithm for IP column generation, Operations Research Letters 19 (1996) 151–159.[27] G. Wascher, T. Gau, Heuristics for the integer one-dimensional cutting stock problem: A computational study, OR Spektrum 18

(1996) 131–144.

branch-and-price algorithms for the dual bin packing and maximum cardinality bin packing problem

Documents