An Exact Method for the 2D Guillotine Strip Packing Problem

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 ℎ_𝑖(𝑖∈{1,2,…,𝑛}). 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).

(a)

(b)

Figure 1 

(a) Guillotine pattern, (b) nonguillotine pattern.

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], 𝐿_{𝑚𝑚𝑣1} and 𝐿_{𝑚𝑚𝑣2}, 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: 𝐿_𝑐∑=⌈^𝑛𝑖=1ℎ_𝑖𝑤_𝑖𝑊⌉ (2.1) Let 𝐿₀=max{𝐿_𝑐,max_{𝑖=1,…,𝑛}ℎ_𝑖}. Martello et al. [4] proved that the absolute worst case performance ratio is equal to 1/2.

2.2. First Lower Bound 𝐿_{𝑚𝑚𝑣1} (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 𝛼∈[1,𝑊/2],

𝐽₁={𝑗∈𝐽∶𝑤_𝑗>𝑊−𝛼},

𝐽₂={𝑗∈𝐽∶𝑊−𝛼≥𝑤_𝑗>𝑊/2},

𝐽₃={𝑗∈𝐽∶𝑊/2≥𝑤_𝑗≥𝛼}.

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, 𝐿_𝐽1𝐽2. 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 𝐿_𝐽1𝐽2.

2.3. Second Lower Bound 𝐿_{𝑚𝑚𝑣2} (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 𝐿_{𝑚𝑚𝑣2}). This solution is computed by a Branch and Bound. The authors proved that 𝐿_{𝑚𝑚𝑣2} dominates the previous bounds (𝐿_𝑐 and 𝐿_{𝑚𝑚𝑣1}).

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 ⌊ℎ_𝑗/2⌋ slices of height 2 or into ⌊ℎ_𝑗/3⌋ slices of height 3, and so on, until a solvable (1CBP) instance is produced. 𝐿_{𝑚𝑚𝑣2} 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)(𝑥_𝑖,𝑦_𝑖),forall𝑖∈𝐽: the lower-left coordinates of item 𝑖.(ii)𝑚_𝑖,forall𝑖∈𝐽: the index of the bin containing rectangle 𝑖. (iii)𝑙_𝑖𝑗∈{0,1},forall𝑖,𝑗∈𝐽 is equal to 1 if rectangle 𝑖 is located left of rectangle 𝑗, that is, 𝑙_𝑖𝑗=1 if 𝑥_𝑖+𝑤_𝑖≤𝑥_𝑗. (iv)𝑏_𝑖𝑗∈{0,1},forall𝑖,𝑗∈𝐽 is equal to 1 if rectangle 𝑖 is located below rectangle 𝑗, that is, 𝑏_𝑖𝑗=1 if 𝑦_𝑖+ℎ_𝑖≤𝑦_𝑗. 𝑙(MIP1)Min𝑣𝑠.𝑡._𝑖𝑗+𝑙_𝑗𝑖+𝑏_𝑖𝑗+𝑏_𝑗𝑖+𝑝_𝑖𝑗+𝑝_𝑗𝑖𝑥≥1,𝑖,𝑗∈𝐽,𝑖<𝑗,(1)_𝑖−𝑥_𝑗+𝑊𝑙_𝑖𝑗≤𝑊−𝑤_𝑖𝑦,𝑖,𝑗∈𝐽,(2)_𝑖−𝑦_𝑗+𝐻𝑏_𝑖𝑗≤𝐻−ℎ_𝑖𝑚,𝑖,𝑗∈𝐽,(3)_𝑖−𝑚_𝑗+𝑛𝑝_𝑖𝑗≤𝑛−1,𝑖,𝑗∈𝐽,(4)0≤𝑥_𝑖≤𝑊−𝑤_𝑖,𝑖∈𝐽,(5)0≤𝑦_𝑖≤𝐻−ℎ_𝑖,𝑖∈𝐽,(6)1≤𝑚_𝑖𝑙≤𝑣,𝑖∈𝐽,(7)_𝑖𝑗,𝑏_𝑖𝑗,𝑝_𝑖𝑗𝑥∈{0,1},𝑖,𝑗∈𝐽,(8)_𝑖,𝑦_𝑖𝑚∈𝑅,𝑖∈𝐽,(9)_𝑖,𝑣∈𝑁,𝑖∈𝐽,(10) (3.1)(v)𝑝_𝑖𝑗∈{0,1},forall𝑖,𝑗∈𝐽: 𝑝_𝑖𝑗=1 if 𝑚_𝑖+1≤𝑚_𝑗, that is, 𝑝_𝑖𝑗=1 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 𝑙_𝑖𝑗=1, we have: 𝑥_𝑗≥𝑥_𝑖+𝑤_𝑖, which means that item 𝑖 is located left to item 𝑗. If 𝑏_𝑖𝑗=1 in constraint (3), we deduce that item 𝑖 is located below item 𝑗. In constraint (4), we determine if item 𝑖 is packed “before” item 𝑗, 𝑝_𝑖𝑗=1 (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 2𝑆𝑃 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 2𝑆𝑃 problem can be formulated in the following MIP model, denoted (MIP2): 𝑙(MIP2)Min𝐻𝐻𝑠.𝑡._𝑖𝑗+𝑙_𝑗𝑖+𝑏_𝑖𝑗+𝑏_𝑗𝑖𝑥≥1,𝑖,𝑗∈𝐽,𝑖<𝑗,(1)_𝑖−𝑥_𝑗+𝑊𝑙_𝑖𝑗≤𝑊−𝑤_𝑖𝑦,𝑖,𝑗∈𝐽,(2)_𝑖−𝑦_𝑗+𝐻_ℎ𝑏_𝑖𝑗≤𝐻_ℎ−ℎ_𝑖,𝑖,𝑗∈𝐽,(3)0≤𝑥_𝑖≤𝑊−𝑤_𝑖,𝑖∈𝐽(4)0≤𝑦_𝑖≤𝐻_ℎ−ℎ_𝑖,𝑖∈𝐽(5)𝐻𝐻≥𝑦_𝑖+ℎ_𝑖𝑙,𝑖∈𝐽(6)_𝑖𝑗,𝑏_𝑖𝑗∈{0,1},𝑖,𝑗∈𝐽,(7)𝐻𝐻,𝑥_𝑖,𝑦_𝑖∈𝐑,𝑖∈𝐽.(8) (3.2)

The valid inequalities are added to MIP2 in which we relax the integrity constraint (constraints (7) are replaced by the constraints 0≤𝑙_𝑖,𝑗≤1 and 0≤𝑏_𝑖,𝑗≤1, resp.).

In the following, we propose a series of valid inequalities to improve the lower bound of the 2𝑆𝑃 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(𝑃𝑚‖∑𝑤_𝑖𝐶_𝑖): ^𝑛_𝑖=1𝛾_𝑖𝑤_𝑖(𝑦_𝑖+ℎ_𝑖1)≥𝑊^𝑛_𝑖=1𝛾_[𝑖](𝑤_[𝑖]^𝑖−1_𝑗=1𝑤_[𝑗]ℎ_[𝑗]+^𝑤[𝑖]_𝑗=1𝑗ℎ_[𝑖])+𝑊−12𝑊^𝑛_𝑖=1𝛾_𝑖𝑤_𝑖ℎ_𝑖, (3.3) 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 𝛾=(𝛾_𝑖)_{1≤𝑖≤𝑛}. 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: 𝐿𝐵𝑀=𝐿𝐵1𝑀+𝑀−12𝑀^𝑁_𝑗=1𝑤_𝑗𝑝_𝑗, (3.4) where 𝐿𝐵1 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 𝑃𝑚‖∑𝑤_𝑖𝐶_𝑖: ^𝑛_𝑖=1𝛾_𝑖ℎ_𝑖(𝑥_𝑖+𝑤_𝑖1)≥𝐻_ℎ^𝑛_𝑖=1𝛾_[𝑖](ℎ_[𝑖]^𝑖−1_𝑗=1𝑤_[𝑗]ℎ_[𝑗]+^ℎ[𝑖]_𝑗=1𝑗𝑤_[𝑖]𝐻)+^ℎ−12𝐻_ℎ^𝑛_𝑖=1𝛾_𝑖𝑤_𝑖ℎ_𝑖, (3.5) where [𝑖] is the 𝑖th item when the set 𝐽 is sorted in nondecreasing order of 𝑤_𝑖/𝛾_𝑖.

This constraint is valid for any vector 𝛾=(𝛾_𝑖)_{1≤𝑖≤𝑛} 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: ^𝑛_𝑖=1𝛾_𝑖𝑤_𝑖𝑦^′_𝑖≥1𝑊^𝑛_𝑖=1𝛾_[𝑖](𝑤_[𝑖]^𝑖−1_𝑗=1𝑤_[𝑗]ℎ_[𝑗]+^𝑤[𝑖]_𝑗=1𝑗ℎ_[𝑖])+𝑊−12𝑊^𝑛_𝑖=1𝛾_𝑖𝑤_𝑖ℎ_𝑖, (3.6) or 𝐻^𝑛_𝑖=1𝛾_𝑖𝑤_𝑖≥^𝑛_𝑖=1𝛾_𝑖𝑤_𝑖𝑦_𝑖+1𝑊^𝑛_𝑖=1𝛾_[𝑖](𝑤_[𝑖]^𝑖−1_𝑗=1𝑤_[𝑗]ℎ_[𝑗]+^𝑤[𝑖]_𝑗=1𝑗ℎ_[𝑖])+𝑊−12𝑊^𝑛_𝑖=1𝛾_𝑖𝑤_𝑖ℎ_𝑖. (3.7)

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: 𝑊^𝑛_𝑖=1𝛾_𝑖ℎ_𝑖≥^𝑛_𝑖=1𝛾_𝑖ℎ_𝑖𝑥_𝑖+1𝐻_ℎ^𝑛_𝑖=1𝛾_[𝑖](ℎ_[𝑖]^𝑖−1_𝑗=1𝑤_[𝑗]ℎ_[𝑗]+^ℎ[𝑖]_𝑗=1𝑗𝑤_[𝑖]𝐻)+^ℎ−12𝐻_ℎ^𝑛_𝑖=1𝛾_𝑖𝑤_𝑖ℎ_𝑖. (3.8)

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 𝒢={𝑖∣forall𝑗∈𝒢 and 𝑗≠𝑖, we have 𝑤_𝑖+𝑤_𝑗>𝑊}. The following constraints are valid inequalities: 𝑙_𝑖,𝑗+𝑙_𝑗,𝑖𝑏=0∀𝑖,𝑗∈𝒢,𝑗≠𝑖,_𝑖,𝑗+𝑏_𝑗,𝑖=1∀𝑖,𝑗∈𝒢,𝑗≠𝑖 (3.9) Let (𝛾_𝑖)_{1≤𝑖≤|𝒢|} be a vector of fictitious weights. [𝑖]_{1≤𝑖≤|𝒢|} represents the 𝑖th item of the set 𝒢 by sorting the items in nondecreasing order of ℎ_𝑖/𝛾_𝑖. The following constraint defines a valid inequality: _𝑖∈𝒢𝛾_𝑖(𝑦_𝑖+ℎ_𝑖)≥^|𝒢|_𝑖=1𝛾_[𝑖](^𝑖_𝑗=1ℎ_[𝑗]). (3.10) Obviously, the following constraint is also a valid inequality: 𝐻𝐻_𝑖∈𝒢𝛾_𝑖≥_𝑖∈𝒢𝛾_𝑖𝑦_𝑖+^|𝒢|_𝑖=1𝛾_[𝑖](^𝑖_𝑗=1ℎ_[𝑗]) (3.11) We use the same reasoning in the previous cut. Let 𝒢^′={𝑖∣forall𝑗∈𝒢^′ and 𝑗≠𝑖,wehaveℎ_𝑖+ℎ_𝑗>𝐻_ℎ}. The following constraints are valid inequalities: 𝑙_𝑖,𝑗+𝑙_𝑗,𝑖=1∀𝑖,𝑗∈𝒢^′𝑏,𝑗≠𝑖,_𝑖,𝑗+𝑏_𝑗,𝑖=0∀𝑖,𝑗∈𝒢^′,𝑗≠𝑖. (3.12)

Let (𝛾_𝑖)_{1≤𝑖≤|𝒢′|} be a vector of fictitious weights. [𝑖]_{1≤𝑖≤|𝒢′|} represents the 𝑖th item in the set 𝒢^′ when it is sorted in the nondecreasing order of 𝑤_𝑖/𝛾_𝑖. The following constraint is a valid inequality: _{𝑖∈𝒢′}𝛾_𝑖(𝑥_𝑖+𝑤_𝑖)≥^|𝒢′|_𝑖=1𝛾_[𝑖](^𝑖_𝑗=1𝑤_[𝑗]). (3.13) The following constraint is also a valid inequality: 𝑊_{𝑖∈𝒢′}𝛾_𝑖≥_{𝑖∈𝒢′}𝛾_𝑖𝑥_𝑖+^|𝒢′|_𝑖=1𝛾_[𝑖](^𝑖_𝑗=1𝑤_[𝑗]). (3.14)

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 (𝑦_𝑖=0) 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 𝒱={𝑖∣𝑦_𝑖=0in𝒮}. 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: _𝑖∈𝒱𝑤_𝑖(𝑦_𝑖+ℎ_𝑖)≥𝑆𝑃𝑇(𝒱). (3.15)

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: 𝑦_𝑗≥^𝑖=𝑛_{𝑖=1∩𝑖≠𝑗}ℎ_𝑖𝑤_𝑖𝑏_𝑖,𝑗𝑊,𝑥_𝑗≥^𝑖=𝑛_{𝑖=1∩𝑖≠𝑗}ℎ_𝑖𝑤_𝑖𝑙_𝑖,𝑗𝐻_ℎ,𝑦_𝑗+ℎ_𝑗≤𝐻𝐻−^𝑖=𝑛_{𝑖=1∩𝑖≠𝑗}ℎ_𝑖𝑤_𝑖𝑏_𝑗,𝑖𝑊,𝑥_𝑗+𝑤_𝑗≤𝑊−^𝑖=𝑛_{𝑖=1∩𝑖≠𝑗}ℎ_𝑖𝑤_𝑖𝑙_𝑗,𝑖𝐻_ℎ. (3.16)

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)): 𝑅_𝑖(𝑥_𝑖,𝑦_𝑖,𝑤_𝑖,𝑦_𝑝−𝑦_𝑖).

(a) The item is located in the right side of 𝑅𝑖

(b) The item is located in the left side of 𝑅𝑖

Figure 2 

Updating the set of available rectangles in 𝑁𝑆𝐻𝐹.

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. 𝑀_𝑖𝑗={left,right, below,above} 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

𝑟_𝑖𝑗∈𝑀_𝑖𝑗,𝑖,𝑗∈{1,…,𝑛}, i≠j,

𝑟_𝑖𝑗=left⇒𝑥_𝑖+𝑤_𝑖≤𝑥_𝑗,𝑖,𝑗∈{1,…,𝑛}, i≠j,

𝑟_𝑖𝑗=right⇒𝑥_𝑗+𝑤_𝑗≤𝑥_𝑖,𝑖,𝑗∈{1,…,𝑛}, i≠j,

𝑟_𝑖𝑗=below⇒𝑦_𝑖+ℎ_𝑖≤𝑦_𝑗,𝑖,𝑗∈{1,…,𝑛}, i≠j,

𝑟_𝑖𝑗=above⇒𝑦_𝑗+ℎ_𝑗≤𝑦_𝑖,𝑖,𝑗∈{1,…,𝑛}, i≠j,

0≤𝑥_𝑖≤𝑊−𝑤_𝑖,𝑖∈{1,…,𝑛},

0 ≤𝑦_𝑖≤𝐻−ℎ_𝑖,𝑖∈{1,…,𝑛}.

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:

Table 1 

Comparison of BSHF and NSHF heuristics and literature heuristics.

(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:

Table 2 

Results of exact algorithms on Hifi’s instances.

(i)the width 𝑊 of the strip and the number of items 𝑛, (ii)values of upper bound 𝑈𝐵 and lower bound 𝐿𝐵 computed by the methods described previously, (iii)values of lower bound 𝐿_min computed by Hifi [12], (iv)values of the optimal solution 𝑂𝑃𝑇, and(v)the computational time of Hifi [12] 𝑇_ℎ, that of our branch and bound 𝑇_𝑏, and that of the dichotomic algorithm 𝑇_Dich (in seconds).

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:

Table 3 

Results of exact algorithms on literature instances.

(i)problem name and values of 𝑛 and 𝑊, (ii)values of the our lower bound 𝐿𝐵 and values of the upper bound 𝑈𝐵, (iii)values of lower bound 𝐿_{𝑚𝑚𝑣2} computed by Martello et al. [4], (iv)values of the solutions: branch and bound (𝑆_𝐵&𝐵) and dichotomic algorithm (𝑆_Dich), and(v)the computation time of the branch and bound 𝑇_𝐵&𝐵 and that of the dichotomic algorithm 𝑇_Dich (in seconds).

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]:

𝑗=1,…,𝑛. 𝑛=10,15,20,25,

Class I: 𝑤_𝑗𝑎𝑛𝑑ℎ_𝑗uniformly random in[1,10],𝑊=10;

Class II: 𝑤_𝑗𝑎𝑛𝑑ℎ_𝑗uniformly random in[1,10],𝑊=30;

Class III: 𝑤_𝑗𝑎𝑛𝑑ℎ_𝑗uniformly random in[1,35],𝑊=40;

Class IV: 𝑤_𝑗𝑎𝑛𝑑ℎ_𝑗uniformly random in[1,35],𝑊=100;

Class V: 𝑤_𝑗𝑎𝑛𝑑ℎ_𝑗uniformly random in[1,100],𝑊=100;

Class VI: 𝑤_𝑗𝑎𝑛𝑑ℎ_𝑗uniformly random in [1,100],𝑊=300.

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

Type 1: wj uniformly random in[2/3𝑊,𝑊], hj uniformly random in[1,𝑊/2];

Type 2: wj uniformly random in[1,𝑊/2], hj uniformly random in [2/3𝑊,𝑊];

Type 3: wj uniformly random in[𝑊/2,𝑊], hj uniformly random in [𝑊/2,𝑊];

Type 4: wj uniformly random in[1,𝑊/2],hj uniformly random in[1,𝑊/2].

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

Class VII: type 1with probability of70%,𝑡𝑦𝑝𝑒2,3,4 with probability of 10%each;

Class VIII: type 2with probability of 70%,𝑡𝑦𝑝𝑒1,3,4with probability of10%each;

Class IX: type 3with probability of 70%,𝑡𝑦𝑝𝑒1,2,4 with probability of10%each;

Class X: type 4with probability of70%,𝑡𝑦𝑝𝑒1,2,3 with probability of10%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)𝑆_Dich 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.

Table 4 

Results obtained by dichotomic and branch-and-bound algorithms on random instances.

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.

input: 𝑛: number of items;   𝑙𝑖𝑠𝑡𝑃: list of items with their dimensions;   𝑊: the width of the strip;   𝑇𝐿: the limit of the algorithm running time;   output: 𝐻, the optimal height to pack all items  1 //Functions;  2 UBF(n, listP, W) : the function computing the upper bounds;  3 𝐿𝐵𝐹(n, listP, W) : the function computing the lower bounds;  4 OPP(n, S, W1, H1) : this procedure returns TRUE if the set of items 𝑆 can be packed in   a bin of width 𝑊1 and height 𝐻1;  5 //initialization;  6 𝐿𝐵∶=𝐿𝐵𝐹(𝑛,𝑙𝑖𝑠𝑡𝑃,𝑊);  7 𝑈𝐵∶=𝑈𝐵𝐹(𝑛,𝑙𝑖𝑠𝑡𝑃,𝑊);  8 if (𝐿𝐵==𝑈𝐵) then  9  Return 𝐿𝐵; STOP; 10 else 11   if OPP (𝑛,𝑙𝑖𝑠𝑡𝑃,𝑊,𝐿𝐵)==TRUE then 12    Return 𝐿𝐵; STOP; 13   else 14    while ((𝐿𝐵<𝑈𝐵)𝑎𝑛𝑑(𝑇𝑖𝑚𝑒<𝑇𝐿)) do 15      if (𝑈𝐵−𝐿𝐵==1) then 16       Return 𝑈𝐵; STOP; 17      else 18       𝑆∶=0𝑥0𝑓8𝑓0⌊(𝑈𝐵+𝐿𝐵)/20𝑥0𝑓8𝑓𝑏⌋; 19       if OPP (𝑛,𝑙𝑖𝑠𝑡𝑃,𝑊,𝑆)==𝑇𝑅𝑈𝐸 then 20         𝑈𝐵∶=𝑆; 21       else 22         𝐿𝐵∶=𝑆;

Algorithm 1 

Dichotomic Algorithm (Bekrar et al. [14]).

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.