Advances in Operations Research

Volume 2009, Article ID 732010, 20 pages

http://dx.doi.org/10.1155/2009/732010

## An Exact Method for the 2D Guillotine Strip Packing Problem

^{1}Research and Development Department in Algorithmic, DynaSys S.A., Allee de Stockholm, 67300 Schiltigheim, France^{2}LITA Laboratory, University of Paul Verlaine Metz, Ile du Saulcy, 57000 Metz, France

Received 24 August 2008; Revised 13 January 2009; Accepted 16 April 2009

Academic Editor: Mhand Hifi

Copyright © 2009 Abdelghani Bekrar and Imed Kacem. This is an open access article distributed under the Creative Commons Attribution License, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.

#### Abstract

We consider the two-dimensional strip packing problem with guillotine cuts. The problem consists in packing a set of rectangular items on one strip of width and infinite height. The items packed without overlapping must be extracted by a series of cuts that go from one edge to the opposite edge (guillotine constraint). To solve this problem, we use a dichotomic algorithm that uses a lower bound, an upper bound, and a feasibility test algorithm. The lower bound is based on solving a linear program by introducing new valid inequalities. A new heuristic is used to compute the upper bound. Computational results show that the dichotomic algorithm, using the new bounds, gives good results compared to existing methods.

#### 1. Introduction

The two-dimensional strip packing problem (2SP) is a well-known combinatorial optimization problem. It has several industrial applications like the cutting of rolls of paper or textile material. Moreover, some approximation algorithms for bin packing problems are in two phases where the first phase aims to solve a strip packing problem [1, 2]. Consider a set of rectangular items. Each item has a width and a height . The 2SP consists in packing all the items in a strip of width and infinite height. The dimensions of the items and the strip are integers. The objective is to minimize the total height used to pack the items without overlapping. The orientation of items is fixed, that is, they cannot be rotated.

This problem is NP-hard in the strong sense since the special case where all items have the same height is equivalent to the one-dimensional bin packing [3, 4].

An additional constraint considered in this paper is the guillotine cut: All items must be extracted by cuts that go from one edge to the opposite edge. Figure 1(a) shows a guillotine pattern where all items can be extracted by guillotine cuts. When items cannot be extracted by guillotine cuts, the pattern is called nonguillotine as shown in Figure 1(b).

Most of papers considering the 2SP problem are approximation algorithms. Fernandez de la Vega and Zissimopoulos [5], Lesh et al. [6] Kenyon and Rémila [7], and Zhang et al. [8] presented approximation algorithms for the strip packing problem. Bortfeldt [9], and Beltran et al. [10] used metaheuristics. Hopper and Turton [11] provided an overview of metaheuristic algorithms applied to 2D strip packing problem.

To the best of our knowledge, there are only few papers which used exact algorithms to solve 2SP problem. Hifi [12] introduced the cutting/packing problem with guillotine cut, and he proposed two algorithms based on branch and bound. Martello et al. [4] proposed a new lower bound and used a branch and bound to solve the problem without guillotine constraint.

Recently, three papers introduced the strip packing problem with guillotine constraint. Cui et al. [13] proposed a recursive branch and bound to obtain an approximate solution. A new lower bound and a Branch and Bound were proposed by Bekrar et al. [14]. Finally, Cintra et al. [15] used the column generation method and dynamic programming to solve another variant of the problem (a bound on the number of each small rectangle to be packed is imposed).

In this paper, we propose an exact algorithm based on dichotomic search to solve the two-dimensional strip packing problem with guillotine cut. In Section 2 we present some lower bounds proposed in literature. In Sections 3 and 4, we, respectively, present the lower bound and the upper bound used in the algorithm. In Section 5, we explain the dichotomic algorithm. We provide computational results in Section 6. Finally, we discuss some perspectives of our work.

#### 2. Lower Bounds for the 2SP Problem

In this section, we first recall *existing* lower bounds proposed for the strip packing problem: the continuous lower bound , the lower bounds of Martello et al. [4], and , and our lower bound proposed in Bekrar et al. [16], . Note that, in all lower bounds the guillotine constraint is relaxed.

##### 2.1. The Continuous Lower Bound

By splitting each item into unit squares, we obtain a lower bound which is called the *continuous lower bound*:
Let . Martello et al. [4] proved that the absolute worst case performance ratio is equal to .

##### 2.2. First Lower Bound (Martello et al. [4])

This first lower bound presented by Martello et al. [4] is an extension of the one presented in Martello and Toth [17] proposed for the one-dimensional bin packing problem. The idea is to decompose the set of items () into three subsets according to their dimensions: the subset of the largest items (), the subset of medium items (), and the subset of the smallest items ().

Let ,

,

,

Observe that

(i)beside a large item we cannot pack any item of the other subsets, (ii)two items of the subset of medium items cannot be packed one beside the other, and(iii)beside items of medium items only items of the last class can be packed.The sum of heights of items in the two first classes is a valid lower bound for the 2SP problem, . Some items of cannot be packed beside the first class or the second class. A continuous lower bound on those items is computed and added to .

##### 2.3. Second Lower Bound (Martello et al. [4])

The second lower bound proposed by Martello et al. [4] is based on a relaxation of the 2SP problem by cutting each item into unit-height *slices* of width . The authors consider the *one-dimensional contiguous bin packing problem (1CBP)*, where all slices must be packed in bins of size . The slices derived from the item must be packed into contiguous bins. The optimal solution value of (1CBP) is a valid lower bound for the 2SP problem (denoted ). This solution is computed by a Branch and Bound. The authors proved that dominates the previous bounds ( and ).

When the Branch and Bound fails in determining the optimal solution within a fixed time, a new instance of (1CBP) is created from the 2SP instance by cutting each item into slices of height 2 or into slices of height 3, and so on, until a solvable (1CBP) instance is produced. is improved by using a special binary search procedure (for more details see [4]).

This lower bound gives the best results on the tested instances, but as we can remark it is complicated and it takes considerable computation time.

##### 2.4. Bekrar et al. [14] Lower Bound ()

This lower bound is based on the same decomposition presented in Martello et al. [4]. The idea is to calculate the maximum number of items from the last class that can be packed beside items of the second class . This allowed us to compute a best bound on the items of that cannot be packed with .

This lower bound gives good results on the same instances of Martello et al. [4] with the advantage of reducing the computation time.

#### 3. MIP Formulation and Introduction of Valid Inequalities

This method is based on an adapted formulation of the problem in a mixed integer programming. It is impossible to solve effectively this problem by a commercial solver because of the large number of constraints and variables. *In addition*, the linear relaxation (relaxation of the integrity constraint) is very poor. This is why we add a family of valid inequalities to the model to improve the lower bound associated to its linear relaxation.

##### 3.1. The MIP Formulation for the Two-Dimensional Bin Packing Problem (Pisinger and Sigurd [18])

The model which we used is adapted from the one presented by Pisinger and Sigurd [18] for the two-dimensional bin packing problem. The latter is based on the modeling technique proposed by Onodera et al. [19] and Chen et al. [20] described as follows.

Let denote the set of items. are, respectively, the width and the length of the bin.

*Decision Variables*

Consider the following variables. (i): the lower-left coordinates of item .(ii): the index of the bin containing rectangle . (iii) is equal to 1 if rectangle is located left of rectangle , that is, if . (iv) is equal to 1 if rectangle is located below rectangle , that is, if .
(v): if , that is, if rectangle is packed in a bin before the bin where rectangle is packed (the index of the bin containing is less than the bin containing ). (vi) is the number of used bins. Constraints (1) avoids the overlapping between items, so item should be in the left or the right side of item , and, in the same time, it should be located above or below item . In constraint (2), if , we have: , which means that item is located left to item . If in constraint (3), we deduce that item is located below item . In constraint (4), we determine if item is packed “before” item , (the index of the bin containing is less than the index of the bin containing ). These three constraints determine the position of item relative to the position of item . Constraints (5) and (6) ensure that the items do not exceed the edges of the bins.

##### 3.2. MIP Formulation for the Two-Dimensional Strip Packing Problem 2SP

We adapted the model of Pisinger and Sigurd [18] for the problem. Constraints (4), (7), and (10) are eliminated since they concern the bin packing problem. The length of the bin is replaced by an upper bound corresponding to the length of the strip.

The problem can be formulated in the following MIP model, denoted :

The valid inequalities are added to in which we relax the integrity constraint (constraints (7) are replaced by the constraints and , resp.).

In the following, we propose a series of valid inequalities to improve the lower bound of the problem.

##### 3.3. Inequalities Related to the Parallel-Machine Scheduling Problem and

This bound is inspired from the principle proposed in Kacem [21] applied to the tardiness minimization on a single machine. Kacem [21] associates fictitious weights to jobs to be scheduled and computes a lower bound on the weighted flow-time of the optimal solution. Therefore, for each vector of fictitious weights, he obtained a valid inequality. For the studied problem, we consider the items as a set of jobs (i.e., each item is a set of jobs of duration ) to be scheduled on identical parallel machines. Hence, the variables represents the completion time of the item (all the jobs corresponding to this item). Clearly, feasible packing can be viewed as a schedule of these fictitious jobs. To each item , we associate a fictitious weight . We use an iterative method to calculate different values of weights. For each vector of fictitious weights, we obtain a valid inequality. We deduce the following valid inequality based on the lower bound of Eastman et al. [22] for the *problem of minimizing the weighted flow-time on identical parallel machines*:
where is the item in position when the set is sorted in non-decreasing order of . This constraint is valid for any positive vector of fictitious weight . We generated several constraints of this type.

Recall that the bound of Eastman et al. [22] for the problem is given by the following equation:
where is the optimal solution of the problem on a single machine. is the number of machines, and is the number of jobs. and are, respectively, the weight and the duration of the job *.*

##### 3.4. Inequalities Related to the Parallel-Machine Scheduling Problem and

This inequality consists in the same principle. We consider items as jobs; each item is considered as a set of jobs of duration . These jobs are to be scheduled on identical machines. Therefore, the variables represent the completion time of the item . It is obvious that any feasible packing can be viewed as a scheduling of fictitious jobs.

To each job , a fictitious weight is associated. Hence, we deduce the following valid inequalities that used the bound of Eastman et al. [22] for the problem : where is the th item when the set is sorted in nondecreasing order of .

This constraint is valid for any vector of fictitious weights. For this reason, we generate several constraints of this family.

##### 3.5. Inequalities Linking and

By solving the model with the previous cuts (Sections 3.3 and 3.4), we noticed that in the obtained solutions items are in the bottom and in the right of the strip to respect these inequalities. To avoid this problem, we adopted the solution which consists in bounding the weighted sum of .

We apply the same reasoning used in the previous inequality, and then we can obtain a valid inequality able to link and . Indeed, by replacing (, i.e., ) and using a similar notation as in the first family (Section 3.3), we can introduce the following inequality: or

##### 3.6. Inequalities Bounding the Weighted Sum on

This inequality is similar to the previous one. It is based on the following transformation of variables: . It is described as follows:

##### 3.7. Inequalities for large items and high items

For the set of large items such that each pair cannot be packed side by side, we can consider it as items of width . Indeed, let and we have . The following constraints are valid inequalities: Let be a vector of fictitious weights. represents the th item of the set by sorting the items in nondecreasing order of . The following constraint defines a valid inequality: Obviously, the following constraint is also a valid inequality: We use the same reasoning in the previous cut. Let and . The following constraints are valid inequalities:

Let be a vector of fictitious weights. represents the th item in the set when it is sorted in the nondecreasing order of . The following constraint is a valid inequality: The following constraint is also a valid inequality:

##### 3.8. Inequalities with Identical Fictitious Weights

It is obvious that all the previous cuts remain valid for the special case when the fictitious weights are equal to 1. However, it is more advantageous in this case to apply the *Shortest Processing Time (SPT)* rule instead of the Eastman bound.

We established a simple procedure to apply this rule to our problem in which we consider items as jobs.

##### 3.9. Valid Constraints Avoiding the Overlapping of Items in the Bottom of the Strip

When we tested the previous cuts, we noticed in some obtained solutions that items overlap in the bottom of the strip () while the sum of their widths exceeds the width of the strip . Therefore, we introduced a special cut to avoid this situation for which a constraint of the initial problem is violated.

Let be the real solution violated and . We have . We apply for the items of this set a cut of the same type of the first one with fictitious weights equal to 1 (Section 3.3). Obviously, we do not use the bound of Eastman but the generalized mentioned previously. Let be the value of this bound calculated for the set . The following constraint is a valid cut:

We observed that, in some solutions, items overlap on the other sides of the strip. Using the same approach, we can see that this cut can be immediately generalized for the items on the top, on the right edge, and the left edge of the strip.

##### 3.10. Valid Constraints Based on Precedence Considerations

For all , the following relations hold due to the precedence considerations:

#### 4. Upper Bounds for the 2SP Problem

##### 4.1. The Two-Dimensional Level Algorithms

Many papers proposed approximation algorithms for 2D Strip Packing Problem, but few of them consider the guillotine constraint, citing from this category: Fernandez de la Vega and Zissimopoulos [5], Lesh et al. [6], Kenyon and Rémila [7], Zhang et al. [8], and Cui et al. [13]

To maintain this constraint, most of the proposed approaches are level algorithms, that is, the strip packing is obtained by placing the items, from left to right, in rows forming levels. The set of items is sorted in decreasing order of their heights. The first item packed in the bottom-left of the strip initializes the first level. The remaining items are packed in the initialized levels according to the used strategy (Best Fit (BFDH), First Fit (FFDH), Next Fit (NFDH), etc.). If no initialized level can contain the current item, a new level is initialized.

##### 4.2. The Best Shelf Heuristic Filling (BSHF)

The Shelf Heuristic Filling (SHF) algorithm was proposed previously by Ben Messaoud et al. [23]. It is a generalization of the two-dimensional level algorithms (for more details about level algorithms like Floor Ceiling, see Lodi et al. [24]).

The main idea of SHF algorithm is to exploit the nonused area in each shelf. It makes it possible to pack items one over the other in the same shelf, which is not permitted in the level algorithms. This packing is achieved by respecting the guillotine constraint. For this purpose, SHF uses the definition of the available rectangle: the rectangle which has its bottom left corner as an *available point*. The available point can be the down-right or the top-left corner of an item already packed. Items are sorted in nonincreasing order of heights. The first item (the tallest one) is packed into the first available rectangle (the lowest). The leftmost item initializes a shelf with a height equal to the height of this item. After every item-packing, the set of available rectangles is updated in order to maintain the guillotine constraint. The updating consists in reducing the dimensions of available rectangles which overlap with the packed items. The item-packing creates two new available rectangles. This procedure is repeated until the last item is packed.

In Bekrar et al. [14], we proposed some strategies to improve the SHF algorithm. We called this new heuristic BSHF (Best SHF). We tested different rules of sorting items. We used the Best Fit rule to pack items, and we proposed a new way to update the list of available rectangles. The Best Fit rule consists in packing items in the available rectangle that minimizes the unused surface. This algorithm gives good results on large instances in few seconds. The average waste rate is estimated at 9%.

##### 4.3. A New Heuristic for Solving the 2D Strip Packing Problem

In this subsection we present a new heuristic that is able to solve approximately the 2SP problem with guillotine cuts. Unlike previous heuristics (BSHF and BFDH), the items are not packed according to levels.

The items are sorted in different orders (decreasing heights, decreasing widths, decreasing areas).

The items are then packed in available rectangle as it is done in BSHF. However, the set of available rectangles is not updated in the same manner. When the current item can fill in an available rectangle, we check if the obtained pattern is guillotine using the procedure proposed by Ben Messaoud et al. [23]. If this pattern is guillotine, then the packing is validated and the next item is treated; otherwise, we try with another available rectangle.

During the packing, no shelf is created, hence the name of the algorithm: Nonshelf Heuristic Filling. The heuristic is adapted to the two-dimensional bin packing problem; when the current item cannot be packed in the open bins, a new bin is initialized.

The updating procedure in the BSHF heuristic aims to maintain the guillotine property of the patterns. In the NSHF heuristic, the updating procedure aims to *correct* the dimension of the available rectangles that are overlapping with the packed item.

Let be an available rectangle that has a width and a height and position . The bottom-left point coordinates of are and . Let an item with a width and a height be packed in the position . We distinguish two possibilities.

(1)*Case 1*. , the item is located in the right side of . If overlaps with , (i.e., ) then the width of is reduced (Figure 2(a)): . (2)

*Case 2*. , the item is located in the left side of . If overlaps with (i.e., ), then the height of is reduced (Figure 2(b)): .

#### 5. The Dichotomic Algorithm

In this section we present an exact method to solve the problem to optimality. The principle of this method was introduced first by Hifi [12]. Its effectiveness has been shown on other packing problems.

The algorithm starts by computing the lower bound using the cutting plane method described in Section 3. An upper bound, , is then computed by the heuristic *BSHF* and *NSHF* described in Section 4. If the upper bound is equal to the lower bound, then this is the optimal solution. If it is not the case, we search the optimal length included in the interval for which the items can be packed.

To reduce the search space, we use a dichotomic search. The Dichotomic Algorithm is sketched in Algorithm 1. The principle of this method was exploited in a previous work of Bekrar et al. [14].

When a height is chosen from the interval , a decision problem is generated: could the set of items be packed in the bin of width and height ? The problem of determining if a set of rectangles can be packed in a larger rectangle of fixed size is well known as the two-dimensional orthogonal packing problem (2OPP).

Several papers were interested in this problem. Fekete et al. [25] proposed an exact algorithm based on the graph theory. Clautiaux et al. [26, 27] proposed two approaches to solve 2OPP to optimality. The first one is a two-step algorithm where they determined the *x-*coordinates of items in the first step, then they checked the feasibility of the obtained configurations in the second step Clautiaux et al. [26]. In Clautiaux et al. [27], they used another approach based on constraint programming. The constraint programming approach was also used by Pisinger and Sigurd [18].

We choose to use the last approach in our algorithm, because it maintains the guillotine constraint, and we have experimentally checked that it has less computational time.

The (2OPP) is solved by a constraint satisfaction program (CSP). Constraint Satisfaction Programming (CSP) is a field of Artificial Intelligence that looks to solve problems modeled by a set of constraints imposed on a finite set of variables. The set of variables is defined in a domain: a finite set of values for each variable. A solution to CSP is a complete assignment of variables satisfying all the constraints.

For each pair of items , the domain is associated. , determines the possible relative placements among which we should choose at least one. is the variable that determines the position of item according to the position of item . The different relations between items can be defined as

, *i**j,*

, *i**j,*

, *i**j,*

, *i**j,*

, *i**j,*

0

Initially all relations are set to *undefined*.

In each iteration of the algorithm, two rectangles and are considered, and a value is assigned to from . It is then checked whether a feasible assignment of coordinates exists by respecting the current relations . If the coordinate check fails, the algorithm backtracks. Otherwise a recursive call is done.

#### 6. Computational Results

To evaluate the proposed algorithms, we compare them to some literature algorithms. The heuristics *NSHF* and *BSHF* are compared to the best of the algorithm proposed by Hifi [28] and *BFDH* heuristic (Chung et al. [1]). The dichotomic algorithm is compared with the branch and bound of Bekrar et al. [16] and the algorithm of Hifi [12].

All our algorithms were coded in C++ and tested on a Pentium Xeon with 2.7 GHz of RAM.

##### 6.1. Computational Results for Heuristics

We test our heuristics *BSHF* and *NSHF* to literature heuristics. Hifi [12] proposed four heuristics: FIA, SIA, HC/FIA, and HC/SIA. We compare the best values of those algorithms to our heuristics on the large instances studied by Hifi [12].

In Table 1, we present the results. The following information is given:

(i) and : respectively, the number of items and the strip width, (ii)*LB*: the value of the linear lower bound, (iii): the best value obtained by Hifi's heuristics (*FIA, SIA, HC/FIA, HC/SIA*), (iv)*XSHF*: the best value obtained by our heuristics *NSHF* and *BSHF*(v)*BFDH*: results of *BFDH* heuristic, and(vi)*A*/*LB*: the ratio of each heuristic by the lower bound ( represents the value of solution obtained by the heuristic). As we can see in Table 1, our algorithms allow to obtain satisfactory solutions on the tested instances. It improves generally the existing solutions. Note that Hifi's algorithm remains the best for instance (SCPL7). This confirms the interest of our heuristics.

##### 6.2. Computational Results on Hifi’s Instances

The first tests are carried out on the instances of Hifi [12]. The dichotomic algorithm is compared to the branch and bound of Bekrar et al. [14] and to the best-first search MVB algorithm of Hifi [12]. The 25 instances are of various sizes and are available at http://www.laria.u-picardie.fr/hifi/OR-Benchmark/Strip-cutting/Strip-cutting.html.

In Table 2, we give for each problem instance the following:

Note that we carry out our algorithms for one hour, and if the optimal solution was not found (marked by “—”), we take the best solution found. Table 2 shows that the dichotomic algorithm could optimally solve all the tested instances of Hifi [12] and outperform our previous branch-and-bound algorithm in computational time, and on only few instances from 25 the dichotomic algorithm was not better. Note that Hifi used a Sparc-Server20 (module 712 MP) to test his algorithm. For this reason, it is not possible to make a reliable comparison in terms of the computation time. However, we prefer to report these results for information completeness.

##### 6.3. Computational Results on Martello’s Instances

The second tests were carried out on a series of instances from literature. All instances are available at http://www.or.deis.unibo.it/research.html.

We compare the dichotomic algorithm to the branch and bound of Bekrar et al. [14]. For each problem, Table 3 gives the following information:

As we can see in Table 3, the dichotomic algorithm often outperforms the Branch and Bound both in the number of solved instances and in the computation time.

##### 6.4. Computational Results on Randomly Instances

To further analyze the performance of the algorithms, we compare the branch-and-bound method and the dichotomic algorithm on instances randomly generated. We adapt the classes of instances proposed by Berkey and Wang [2] and Martello and Vigo [24] for the two-dimensional bin packing problem to the strip packing problem. These instances consist of ten classes of problems. For each class, there are 40 instances: 10 with 10 rectangles, 10 with 15 rectangles, 10 with 20 rectangles, and 10 with 25 rectangles. The first six classes have been proposed by Berkey and Wang [2]:

. ,

*Class I*: *uniformly random in*;

*Class II*: *uniformly random in*;

*Class III*: *uniformly random in*;

*Class IV*: *uniformly random in*;

*Class V*: *uniformly random in*;

*Class VI*: *uniformly random in *.

The remainder four classes were inspired from Martello and Vigo [24]. The items are classified into four types:

*Type 1*: *wj uniformly random in** hj uniformly random in*;

*Type 2*: *wj uniformly random in** hj uniformly random in *;

*Type 3*: *wj uniformly random in** hj uniformly random in *;

*Type 4*: *wj uniformly random in**hj uniformly random in*.

The strip widths are equal to 100 for all these classes, while the items are as follows:

*Class VII*: *type 1**with probability of** with probability of **each*;

*Class VIII*: *type 2**with probability of **with probability of**each*;

*Class IX*: *type 3**with probability of ** with probability of**each*;

*Class X*: *type 4**with probability of** with probability of**each*.

In Table 3, we present the results obtained by testing the two algorithms on random generated instances (TL denotes the time limit). For each 10 instances, we present the average values of

(i): lower bound, (ii): upper bound, (iii) and : the best solution obtained by each algorithm. Each run instance was carried out for 3600 seconds (if no optimal solution was achieved, we take the best one), (iv): the number of found optimum, and(v)T: the average time spent for solving the instance.The results shown in Table 4 confirm the results obtained previously. The dichotomic algorithm outperforms the branch-and-bound method in the number of optimal solutions found and in the average time to compute a solution.

#### 7. Concluding Remarks

In this paper we considered the strip packing problem under the guillotine constraint. The main contribution consists in the elaboration of new tight lower and upper bounds. The upper bounds are based on new rules for solving the problem under the above constraint. The lower bounds are based on a linear formulation using a set of various valid inequalities with a connection to scheduling on parallel machines. Such bounds were very useful to build an efficient dichotomic method which we compared to an existing branch-and-bound method. Based on the experimental results, several concluding remarks are worthy to note.

On the instances of Hifi our dichotomic algorithm was able to solve all the instances generally in a shorter computation time compared to our previous branch-and-bound method. Indeed, for the same instances our previous branch-and-bound algorithm cannot solve 5 instances of them. The dichotomic algorithm was faster in 16 instances among the 25, where the branch-and-bound algorithm was more efficient only on a few instances (four instances). These results show the effectiveness of the introduction of the new valid inequalities and the new heuristics for computing the bounds. Moreover, our heuristics allow to improve the existing approximate solutions for several instances of the studied benchmark.

For the instances introduced by Martello et al. [4] the same observation remains valid. Here, one can note that the average gap between the solution obtained by the dichotomic algorithm and the lower bound is estimated to 1.5, which represents a good performance on the various and difficult instances.

Finally, the performance of the dichotomic algorithm is confirmed on the random instances. Such an algorithm is more effective and rapid for solving some instances to optimality. In average, this algorithm yielded an optimal solution for 9 instances on 10, where the branch-and-bound algorithm solves only 6 instances on 10.

As for the bin packing problem, the instances of classes V, VI, and VIII were the most difficult to solve. For example, for Class VI, with 25 items the two algorithms were not able to solve more than only one instance on the 10 generated. The other classes are easier since our dichotomic algorithm yielded generally the optimal solution (classes I, II, III, IX) within a short computation time (less than 10 minutes in average). The branch-and-bound algorithm needs more time, and it is less effective to solve optimally the problem (6.6 on 10). The easiness of these instances can be explained by the fact that they are constituted of many small items, which enables the algorithms to compute tight bounds. The classes IX and X are composed of 70 of items having widths greater than the half of the bin width. The bounds computed for this type of instances are very tight. Indeed, the introduction of the inequalities concerning the high and large items (inequalities in Section 3.7) allowed us to obtain a good performance.

As future research, we aim to extend our approach to other variants of packing problems.

#### Acknowledgments

This work has been carried out when the authors are with the University of Technology of Troyes (Institue of Charles Delaunay). The research of the first author has been carried out during a doctoral study funded by the Regional Council of Champagne-Ardenne.

#### References

- F. R. K. Chung, M. R. Garey, and D. S. Johnson, “On packing two-dimensional bins,”
*SIAM Journal on Algebraic and Discrete Methods*, vol. 3, no. 1, pp. 66–76, 1982. View at Google Scholar · View at Zentralblatt MATH · View at MathSciNet - J. O. Berkey and P. Y. Wang, “Two-dimensional finite bin-packing algorithms,”
*Journal of the Operational Research Society*, vol. 38, no. 5, pp. 423–429, 1987. View at Publisher · View at Google Scholar · View at Zentralblatt MATH - M. R. Garey and D. S. Johnson,
*Computers and Intractability: A Guide to the Theory of NP-Completeness*, W. H. Freeman, San Francisco, Calif, USA, 1979. View at Zentralblatt MATH · View at MathSciNet - S. Martello, M. Monaci, and D. Vigo, “An exact approach to the strip-packing problem,”
*INFORMS Journal on Computing*, vol. 15, no. 3, pp. 310–319, 2003. View at Publisher · View at Google Scholar · View at MathSciNet - W. Fernandez de La Vega and V. Zissimopoulos, “An approximation scheme for strip packing of rectangles with bounded dimensions,”
*Discrete Applied Mathematics*, vol. 82, no. 1–3, pp. 93–101, 1998. View at Publisher · View at Google Scholar · View at Zentralblatt MATH · View at MathSciNet - N. Lesh, J. Marks, A. McMahon, and M. Mitzenmacher, “Exhaustive approaches to 2D rectangular perfect packings,”
*Information Processing Letters*, vol. 90, no. 1, pp. 7–14, 2004. View at Publisher · View at Google Scholar · View at MathSciNet - C. Kenyon and E. Rémila, “Approximate strip packing,” in
*Proceedings of the 37th Annual Symposium on Foundations of Computer Science (FOCS '96)*, pp. 31–36, Burlington, Vt, USA, October 1996. View at MathSciNet - D. Zhang, Y. Kang, and A. Deng, “A new heuristic recursive algorithm for the strip rectangular packing problem,”
*Computers & Operations Research*, vol. 33, no. 8, pp. 2209–2217, 2006. View at Publisher · View at Google Scholar · View at Zentralblatt MATH - A. Bortfeldt, “A genetic algorithm for the two-dimensional strip packing problem with rectangular pieces,”
*European Journal of Operational Research*, vol. 172, no. 3, pp. 814–837, 2006. View at Publisher · View at Google Scholar · View at Zentralblatt MATH · View at MathSciNet - J. D. Beltran, J. E. Calderon, R. J. Cabrera, J. A. Moreno Perez, and J. M. Moreno-Vega, “GRASP/VNS hybrid for the strip packing problem,” in
*Proceedings of the 1st International Workshop on Hybrid Metaheuristics (HM '04)*, pp. 79–90, Valencia, Spain, August 2004. - E. Hopper and B. C. H. Turton, “A review of the application of meta-heuristic algorithms to 2D strip packing problems,”
*Artificial Intelligence Review*, vol. 16, no. 4, pp. 257–300, 2001. View at Publisher · View at Google Scholar · View at Zentralblatt MATH - M. Hifi, “Exact algorithms for the guillotine strip cutting/packing problem,”
*Computers & Operations Research*, vol. 25, no. 11, pp. 925–940, 1998. View at Publisher · View at Google Scholar · View at Zentralblatt MATH - Y. Cui, Y. Yang, X. Cheng, and P. Song, “A recursive branch-and-bound algorithm for the rectangular guillotine strip packing problem,”
*Computers & Operations Research*, vol. 35, no. 4, pp. 1281–1291, 2008. View at Publisher · View at Google Scholar · View at Zentralblatt MATH - A. Bekrar, I. Kacem, and C. Chu, “A comparative study of exact algorithms for the two dimensional strip packing problem,”
*Journal of Industrial and Systems Engineering*, vol. 1, no. 2, pp. 151–170, 2007. View at Google Scholar - G. F. Cintra, F. K. Miyazawa, Y. Wakabayashi, and E. C. Xavier, “Algorithms for two-dimensional cutting stock and strip packing problems using dynamic programming and column generation,”
*European Journal of Operational Research*, vol. 191, no. 1, pp. 61–85, 2008. View at Publisher · View at Google Scholar · View at Zentralblatt MATH - A. Bekrar, I. Kacem, C. Chu, and C. Sadfi, “A branch and bound algorithm for solving the 2D strip packing problem,” to apprear in
*International Journal of Production Development*. - S. Martello and P. Toth, “Lower bounds and reduction procedures for the bin packing problem,”
*Discrete Applied Mathematics*, vol. 28, no. 1, pp. 59–70, 1990. View at Publisher · View at Google Scholar · View at Zentralblatt MATH · View at MathSciNet - D. Pisinger and M. Sigurd, “The two-dimensional bin packing problem with variable bin sizes and costs,”
*Discrete Optimization*, vol. 2, no. 2, pp. 154–167, 2005. View at Publisher · View at Google Scholar · View at Zentralblatt MATH · View at MathSciNet - H. Onodera, Y. Taniguchi, and K. Tamaru, “Branch-and-bound placement for building block layout,” in
*Proceedings of the 28th Conference on ACM/IEEE Design Automation Conference*, pp. 433–439, San Francisco, Calif, USA, June 1991. View at Publisher · View at Google Scholar - C. S. Chen, S. M. Lee, and Q. S. Shen, “An analytical model for the container loading problem,”
*European Journal of Operational Research*, vol. 80, no. 1, pp. 68–76, 1995. View at Publisher · View at Google Scholar · View at Zentralblatt MATH - I. Kacem, “Lower bounds for tardiness minimization on a single machine with family setup times,”
*International Journal of Operations Research*, vol. 4, no. 1, pp. 18–31, 2007. View at Google Scholar · View at Zentralblatt MATH · View at MathSciNet - W. L. Eastman, S. Even, and I. M. Isaacs, “Bounds for the optimal scheduling of $n$ jobs on $m$ processors,”
*Management Science*, vol. 11, no. 2, pp. 268–279, 1964. View at Google Scholar · View at MathSciNet - S. Ben Messaoud,
*Caracterisation, modelisation et algorithmes pour des problemes de decoupe guillotine*, Ph.D. thesis, Universite de Technologie de Troyes, Troyes, France, 2004. - A. Lodi, S. Martello, and D. Vigo, “Models and bounds for two-dimensional level packing problems,”
*Journal of Combinatorial Optimization*, vol. 8, no. 3, pp. 363–379, 2004. View at Publisher · View at Google Scholar · View at Zentralblatt MATH · View at MathSciNet - S. P. Fekete, J. Schepers, and J. C. van der Veen, “An exact algorithm for higher-dimensional orthogonal packing,”
*Operations Research*, vol. 55, no. 3, pp. 569–587, 2007. View at Publisher · View at Google Scholar · View at MathSciNet - F. Clautiaux, J. Carlier, and A. Moukrim, “A new exact method for the two-dimensional orthogonal packing problem,”
*European Journal of Operational Research*, vol. 183, no. 3, pp. 1196–1211, 2007. View at Publisher · View at Google Scholar · View at Zentralblatt MATH · View at MathSciNet - F. Clautiaux, A. Jouglet, J. Carlier, and A. Moukrim, “A new constraint programming approach for the orthogonal packing problem,”
*Computers & Operations Research*, vol. 35, no. 3, pp. 944–959, 2008. View at Publisher · View at Google Scholar - M. Hifi, “The strip cutting/packing problem: incremental substrip algorithms-based heuristics,”
*Pesquisa Operacional*, vol. 19, no. 2, pp. 169–188, 1999. View at Google Scholar