An Exact Algorithm for the Two- Dimensional Orthogonal Packing Problem with Unloading Constraints

______________________________

An Exact Algorithm for the Two- Dimensional Orthogonal Packing Problem with Unloading Constraints

Jean-François Côté Michel Gendreau Jean-Yves Potvin

April 2013

CIRRELT-2013-26

G1V 0A6 Bureaux de Montréal : Bureaux de Québec :

Université de Montréal Université Laval

C.P. 6128, succ. Centre-ville 2325, de la Terrasse, bureau 2642 Montréal (Québec) Québec (Québec)

Canada H3C 3J7 Canada G1V 0A6

Téléphone : 514 343-7575 Téléphone : 418 656-2073 Télécopie : 514 343-7121 Télécopie : 418 656-2624

1 Interuniversity Research Centre on Enterprise Networks, Logistics and Transportation (CIRRELT)

2 Department of Computer Science and Operations Research, Université de Montréal, P.O. Box 6128, Station Centre-Ville, Montréal, Canada H3C 3J7

3 Department of Mathematics and Industrial Engineering, École Polytechnique de Montréal, P.O.

Box 6079, Station Centre-ville, Montréal, Canada H3C 3A7

Abstract.

This paper describes a branch-and-cut algorithm for solving a two-dimensional orthogonal packing problem with unloading constraints, which often occurs as a subproblem of mixed vehicle routing and loading problems. At each node of the branching tree, cuts are generated to find a feasible integer solution to a one-dimensional contiguous bin packing problem. If an integer solution is obtained, an auxiliary problem is then solved to find a feasible two-dimensional packing of the items. Different techniques to reduce the size of the solution space and uncover infeasibility are also described. A numerical comparison with the best known exact method is reported at the end on benchmark instances.

Keywords: Vehicle routing, unloading constraints, packing, branch-and-cut.

Acknowledgements.

Financial support for this work was provided by the Natural Sciences and Engineering Research Council of Canada (NSERC). This support is gratefully acknowledged

Results and views expressed in this publication are the sole responsibility of the authors and do not necessarily reflect those of CIRRELT.

Les résultats et opinions contenus dans cette publication ne reflètent pas nécessairement la position du CIRRELT et n'engagent pas sa responsabilité.

_____________________________

* Corresponding author: Jean-Yves.Potvin@cirrelt.ca

Dépôt légal – Bibliothèque et Archives nationales du Québec Bibliothèque et Archives Canada, 2013

1 Introduction

Typically, when solving a mixed vehicle routing and loading problem, a delivery route is first generated and then a feasibility check is performed to determine if the goods can be feasibly packed inside the vehicle. This feasibility problem, in two dimensions (2D) or three dimensions (3D), is far from obvious and the work reported here focuses on this issue.

Let us consider the delivery route R of two-dimensional rectangular objects (called items, thereafter), which is defined as a sequence of cardinality Rover a set of customers J = {1,2, ..., R}. Without loss of generality, we will assume in the following that customerj is the j-th customer in the sequence, that is, customer 1 is delivered first, customer 2 is delivered second, etc. Let us also consider the set of items I = {1, ..., n} to be delivered to the customers, where each item i ∈ I is characterized by its width w_i, its height h_i, as well as its associated customer and delivery order seq_i ∈ {1,2, ..., R} in route R. Note that all items delivered to a given customer have the same delivery order. The loading area of the vehicle (called bin, thereafter) has width W and height H. Given these assumptions, we want to know if the items can fit inside the bin, that is, without overlap and in such a way that the items of any given customer are directly available at delivery time (i.e., the items can be moved out by directly pulling each one of them outside of the bin without moving any other item). The latter characteristic will be referred to as the unloading constraints. It should be noted that the unloading constraints are also referred to assequential loading,rear loading,multi-droporLIFO constraints in the literature. We prefer unloading constraints because these constraints relate to the deliveries.

Figure 1 presents an example for a route that starts from the depot 0 and then visits the customers 1, 2, 3, 4 and 5. Figures 1(a) and 1(b) show two possible packings for this route: the first one satisfies the unloading constraints while the second one does not (note that the items are taken out from the top of the bin, which corresponds to the rear of the vehicle). In the second case, the items of customers 2 must clearly be moved to allow the items of customer 1 to be unloaded.

This problem is the classical 2D Orthogonal Packing Problem (2OPP) with the addition of unloading constraints (UL). The 2OPP is often found as a subproblem of the2D Strip Packing Problem (2SPP) and the2D Bin Packing Problem (2BPP).

Recent exact methods for the 2OPP can be found in [7, 11, 14, 24], while exact methods for the 2SPP are found in [2, 3, 6, 10, 23]. A recent work on the 2SPP with unloading constraints is also reported in [26] where a GRASP heuristic, previously proposed in [1], and two approximation algorithms are used to solve the problem.

The 2OPP-UL occurs in several papers as a subproblem of mixed vehicle routing and loading problems, when unloading constraints apply as well. In these problems, a fleet of vehicles must visit a set of customers while minimizing the total traveled distance. In addition, the items in the route of each vehicle must be feasibly packed.

Infeasible 0

0 3

1 1 1

1 5

2

4 2 2

3 1 3 4

4 5

5 5 H

y

W^{x 0}

H y

W^x

5 3

4 4

3 1

2 2

5 5

1 1 1

Feasible

Figure 1: Packing examples

The literature on this problem distinguishes four main variants, depending if the items can be rotated by 90 degrees (non-oriented) or not (oriented) and if unloading constraints apply or not:

• 2|OU|: two-dimensional oriented with unloading constraints;

• 2|OR|: two-dimensional oriented without unloading constraints;

• 2|N U|: two-dimensional non-oriented with unloading constraints;

• 2|N R|: two-dimensional non-oriented without unloading constraints.

Our work focuses on the 2|OU| variant. The 2|OR| and 2|N R| variants are related to the 2OPP and a vast literature can be found on the subject. We believe that the work reported here can also be generalized to the non-oriented variant 2|N U|.

The heuristics reported in the literature for mixed vehicle routing and loading problems are often local search heuristics which are designed to improve the current solution by applying some modification to it (see, for example, [12, 15, 16, 22, 29]).

A modification to a vehicle route is accepted only if all constraints related to the packing are satisfied. This is typically verified with simple heuristics like the Bottom- Left, Bottom-Left Fill and Touching Perimeter heuristics [29].

Only a few exact algorithms are reported in the literature for these problems due, in particular, to the inherent difficulty of the packing. In [20], a branch-and- cut algorithm is proposed where the classical Bottom-Left heuristic if first used and, if it fails, an exact branch-and-bound algorithm based on the work in [23]

is applied. More recently, the authors in [9] describe a branch-and-cut-and-price

algorithm where a similar, but more involved, tree-based search is proposed. A lower bound that takes into account the unloading constraints is also reported. The reader is referred to the exhaustive surveys in [5, 19] for the three-dimensional case.

When considering the 2OPP, a relaxation known as the One-dimensional Con- tiguous Bin Packing Problem (1CBP) can be used to generate an initial lower bound on the required height of the bin. This relaxation is defined as follows:

Definition 1.1 Given that each item i of width w_i is cut into h_i slices of unitary height, we ask for the packing of all slices into a minimum number of bins of capacity W, in such a way that if the first slice of item i is packed into bin j, then the kth slice is packed into bin j+k,k∈ {1,2, ..., h_i}.

The number of bins obtained is a lower bound on the required height H. That is, if the resulting lower bound is larger than H then the problem is infeasible, otherwise the problem remains undecided. Note that if we have a feasible solution for the 2OPP, a feasible solution of the 1CBP can be obtained by considering the y coordinate of the bottom-left corner of each item as the height position of its starting slice in the 1CBP. Conversely, one could try to build a feasible solution for the 2OPP from a 1CBP solution by using the height position of the first slice of every item as the set ofy-coordinates and then by determining a set ofx-coordinates that does not lead to any overlap. This kind of two-phase approach can be found in [10], although the authors go the other way around by first solving for the x- coordinates and then, for the y-coordinates. Intuitively, this approach looks good in our case, given that the width W (x-axis) of a vehicle’s loading area is typically smaller than its heightH (y-axis). It means that the first problem is smaller, while the second problem exhibits a larger degree of freedom when suitabley-coordinates must be found. Unfortunately, a preliminary computational study has shown that the structure of the x-coordinates obtained by solving the first problem seems to preclude, in most cases, the identification ofy-coordinates that satisfy the unloading constraints.

Given the above observations, we propose a branch-and-cut algorithm to solve the 2OPP-UL, where the 1CBP is first solved to get y-coordinates, followed by a so-called x-check problem to get the corresponding x-coordinates. Several prepro- cessing routines and inequalities that take into account the unloading constraints are also proposed to tighten the problem.

The remainder of the paper is organized as follows. A basic mathematical model is first introduced in Section 2. Then, the outline of the problem-solving methodol- ogy is explained in Section 3. Various inequalities for LP relaxations of the 1CBP are reported in Section 4, including a description of the separation routines associ- ated with these inequalities. Section 5 describes the various preprocessing routines, while the lower bounds are presented in Section 6. Computational results are finally reported in Section 7.

2 Model

In the following, the mathematical notation is first presented. Then, the notion of normal patterns is introduced to reduce, without impairing optimality, the set of solutions to be examined. After these preliminaries, an integer programming model for the 2OPP-UL is reported.

2.1 Notation

The following notation will be used throughout the paper:

• I_i : set of items with delivery orderi(same customer),

• I_i⁼ : set of items delivered at the same time than item i,

• I_i^< : set of items delivered before item i,

• I_i^<,w : set of items delivered before item iof width> w,

• I_i^> : set of items delivered after item i,

• I_i^>,w : set of items delivered after item iof width> w,

• Σ^>_(i)=P

k∈I\{i}

seqk>seqi

w_kh_k : total area of the items delivered after itemi,

• Σ^>,w_(i) =P

k∈I\{i}

seqk>seqi

w_k>w

w_kh_k : total area of the items of width> w delivered after itemi,

• Σ^<_(i,j) = P

k∈I\{i,j}

seqi<seq_k<seqj

w_kh_k : total area of the items delivered after item i but before itemj,

• Σ^<,w_(i,j) =P

j∈I\{i,j}

seqi<seqk<seqj

wk>w

w_kh_k : total area of the items of width> w delivered after itemibut before itemj.

This notation is extended in the following to include items that are delivered at the same time than itemi (i.e., the <and > signs are replaced by ≤and ≥ signs, respectively).

2.2 Normal Patterns

In general, the bottom-left corner of a given itemi∈I can be found at every (x, y) coordinate where x ∈ [0, W −w_i] is the width position and y ∈ [0, H−h_i] is the

height position. This set of coordinates can however be reduced by considering only normal patterns [18], which are defined as follow:

P_i^W ={x= X

j∈I\{i}

w_jξ_j : 0≤x≤W −w_i, ξ_j ∈ {0,1}, j∈I\{i}} (1)

P_i^H ={y= X

j∈I\{i}

h_jξ_j : 0≤y ≤H−h_i, ξ_j ∈ {0,1}, j ∈I\{i}} (2)

When the unloading constraints are considered, the set P_i^H can be reduced by observing that items to be delivered after item icannot be over it:

P_i^H ={y= X

j∈I_i^≥\{i}

h_jξ_j : 0≤y≤H−h_i, ξ_j ∈ {0,1}, j∈I_i^≥\{i}} (3)

We define P^W = S

i∈IP_i^W and P^H = S

i∈IP_i^H as the set of all possible width and height positions. We also define the setP_i^W(r) as the set of positions that cover width position r. The setP_i^H(t) is defined similarly for height positiont:

P_i^W(r) ={x∈P_i^W : [r−wi+ 1]⁺≤x≤r}, i∈I, r∈P^W (4)

P_i^H(t) ={y ∈P_i^H : [t−hi+ 1]⁺≤y≤t}, i∈I, t∈P^H 2.3 Mathematical model

Given the decision variables

• x_ir is 1 if the bottom-left corner of item i is located at width position r, 0 otherwise,i∈I,r ∈P_i^W;

• y_it is 1 if the bottom-left corner of item i is located at height position t, 0 otherwise,i∈I,t∈P_i^H,

we formulate the 2OPP-UL as follow :

(2OPP-UL) X

r∈P_i^W

x_ir = 1 i∈I (5)

X

t∈P_i^H

y_it= 1 i∈I (6)

X

r∈P_i^W(¯r)

x_ir+X

r∈P_j^W(¯r)

x_jr+X

t∈P_i^H(¯t)

y_it+X

t∈P_j^H(¯t)

y_jt ≤3 i∈I, j ∈I_i⁼,r¯∈P^W,t¯∈P^H(7) y_i¯t+X

r∈P_i^W(¯r)

x_ir+X

r∈P_j^W(¯r)

x_jr+X

t∈P_j^H(¯t) t≤¯t+hi−1

y_jt ≤3 i∈I, j ∈I_i^<,r¯∈P^W,t¯∈P_i^H(8)

x_ir ∈ {0,1} r ∈P_i^W, i∈I (9) y_it∈ {0,1} t∈P_i^H, i∈I (10) Constraints (5) and (6) impose a (x,y) coordinate for each item. Constraints (7) insure that no pair of items covers the same (x,y) coordinate. In particular, if items iand j overlap, it is possible to find a coordinate (x,y) such that the left hand side of constraint (7) equals 4. The unloading constraints are imposed through (8). If item i is to be delivered after j and both items cover the same x coordinate (i.e., the summation of the two terms involving the x-coordinates equals 2), then itemj cannot be belowi(i.e., the summation of the two terms involving they-coordinates must be smaller than or equal to 1). The number of constraints of types (7) and (8) is pseudo-polynomial and grows very quickly with W and H, thus leading to a model which is not really useful in practice. Accordingly, the next section will describe an alternative approach to tackle this problem.

3 Problem-solving methodology

In the following, we first describe preprocessing techniques aimed at reducing the number of solutions to be examined. Then, instead of solving directly the 2OPP- UL model, a two-phase approach similar to the one reported in [10] for the 2SPP is applied. Basically, at each node of our branch-and-cut algorithm, a modified 1CBP (formulated as a binary program) is solved to find y coordinates. Then, the correspondingx-check problem is addressed in the second phase.

3.1 Preprocessing

Some preprocessing is first applied to tighten the problem. In this process, infeasi- bility might be uncovered. The algorithmic flow is the following:

1. Apply height position restrictions

2. Apply lifting

3. Calculate lower boundsSP P,L₂,L^H₃ ,L^W₃ 4. From bottom to top-fill do

(a) Apply precedence relations (b) Apply normal pattern dominance

(c) Apply normal pattern removal 5. Select best fill

6. Calculate L^H₄ ,L^W₄

In step 1, the minimum and maximum possible height positions for each item are determined (section 5.1). This is followed by lifting procedures aimed at artificially increasing the item sizes (section 5.2). Then, some lower bounds are calculated (section 6). Different ways of filling the bin, either from the bottom, from the top, or from the bottom and top are considered (section 5.5), while applying normal pattern dominance and normal pattern removal to reduce as much as possible the set of normal patterns (section 5.4). The filling associated with the smallest set of normal patterns is then selected. At the end, two sophisticated bounds, which exploit the current set of normal patterns, are applied (section 6) .

At each step, infeasibility tests are performed to detect if the current set of normal patterns for any given item becomes empty or if the minimum and maximum height positions of any given item are not coherent with the dimensions of the bin (e.g., if the minimum height position of itemimust be larger than H−hi).

3.2 Modified 1CBP

The modified 1CBP has the same variables than the 2OPP-UL and is defined as follow :

(1CBP ) X

t∈P_i^H

y_it= 1 i∈I (11)

X

i∈I

X

¯t∈P_i^H(t)

w_iy_i¯t ≤W t∈P^H (12) X

yit∈S

y_it≤ |S| −1 S∈ S (13) yit∈ {0,1} i∈I, t∈P_i^H (14)

Basically, this is a standard 1CBP but with the number of bins fixed at H.

Constraints (11) state that the first slice of each item must be assigned to a bin.

Constraints (12) ensure that the capacity W of each bin is satisfied. Finally, con- straints (13) correspond toBenders’ feasibility cuts. The set S contains all subsets S = {yit} ∈ S such that an infeasibility occurs in the x-check problem when all variables inS are equal to 1. Given that setS can be very large, these constraints are relaxed in the initial formulation of the problem.

Within the branch-and-cut algorithm, the x-check problem is called each time a binary solution to the current 1CBP linear relaxation is obtained. If the x-check problem is feasible, then we have a feasible solution to the 2OPP-UL. Otherwise, a Benders’ cut of type (13) is added to the 1CBP model. Such an inequality is very weak because it typically removes a single (x,y) coordinate from the solution space. However, stronger cuts can be generated by applying an idea similar to the one in [10]. Let S be the subset of variables equal to 1 in a solution of the 1CBP for which the correspondingx-check problem is infeasible. LetS⁰ ⊂S be such that the correspondingx-check problem is also infeasible. Then, any modification to the y coordinates of the items in S\S⁰ induces a cut that subsumes the cut generated byS. Based on this observation, the set S is reduced as much as possible to obtain a minimal infeasible set (MIS) [8].

To find a MIS, the variables in S = {yit} are considered sequentially from the one with the smallest height position to the one with the largest height position. We remove the chosen variable from S and solve the x-check problem for the reduced set. If it is feasible, the variable is put back in S, otherwise a smaller set that is still infeasible is found. We repeat the procedure until all variables have been considered. Although the order of removal of the variables from set S can lead to different MISs, a single order was considered here (no significant improvement was observed in preliminary tests using multiple MISs). Note also that the resulting inequality cannot be lifted as in [10], because the infeasibility of thex-check problem can come from the unloading constraints.

Apart from the Bender’s cuts, additional cuts are generated when the solution of the current 1CBP linear relaxation is fractional. These inequalities are described in Section 4.

3.3 x-check problem

The model for the x-check problem is obtained by replacing the y_it variables in the 2OPP-UL model by their optimal values in the 1CBP problem. Unfortunately, the resulting model is still too large to be solved in practice with CPLEX. The x-check problem is thus addressed with an enumerative tree search-based approach, which proves to be very efficient. Let ¯yi be the y-coordinate of item iin the 1CBP solution. The algorithm starts by filling the bottom of the bin and then moves up progressively. At the root node, no item is in the bin. Then, for each itemisuch that

¯

y_i = 0 a child node is created withiat coordinate (0,0) in the bin. For subsequent nodes, let (xcur, y_cur) be the current lowest leftmost position. For each itemi such that ¯yi = ycur, a child node is created with item i at (xcur, ycur) if the item fits without overlap and if the unloading constraints are satisfied. An empty node is also created where coordinates (xcur, y_cur) to (xcur+e_x, y_cur+ey) are forbidden with ex= min_i∈I⁰{min_r∈P^W

i {r :r > xcur}},ey = min_i∈I⁰{y¯i: ¯yi > ycur} and I⁰ the set of items that are not yet in the bin.

A node is fathomed when the needed empty space is larger than the available empty space. This simple scheme proved the feasibility or infeasibility of every x-check problem after generating only a few nodes in the branching tree.

4 Inequalities

Before describing our inequalities, we need to introduce the concept of conflicting items or, equivalently, conflicting variables. Let Y be the set of variables in our 1CBP. Let alsoy_iti and y_jtj be two variables in Y. Then, these variables are con- flicting if they cannot cover a commonx-coordinate without overlapping or violating the unloading constraints. Figure 2 b) shows an example where the variables asso- ciated with items 3 and 4 are conflicting. Clearly, at the time of delivery, item 4 needs to be moved to reach item 3, thus violating the unloading constraints. Two variables y_iti and y_jtj are conflicting if they satisfy one of these two conditions:

• seqi < seqj and ti< tj+hj,

• seq_i =seq_j and t_i< t_j+h_j andt_j < t_i+h_i,

Two variablesy_itare also considered to be conflicting if they are associated with the same itemi∈I. The reason is that only one of these variables should be equal to 1, see equation (11).

A subsetC ⊆Y ismutually conflicting if for every pair of variablesyiti, yjtj ∈C, y_itiis conflicting withy_jtj. For example, the setC ={y1t1, y_2t2, y_3t3, y_4t4}is mutually conflicting in both Figures 2 a) and b). In the case of Figure 2 b), the solution is not U L-feasible because the summation over the widths of the items in setCexceedsW. Conversely, the same summation is equal toW in Figure 2 a), which is aU L-feasible solution. This observation can be generalized through the following:

Proposition 4.1 In any feasible 2OPP-UL solution, the summation over the widths of the items in every mutually conflicting set is smaller than or equal to W.

Proof. By contradiction, let us assume that we have a setC={yi1t1, y_i2t2, ..., y_iktk} of mutually conflicting variables in a feasible 2OPP-UL solution such that seq_i1 ≥

1

x 0

1

W a)

H

y

0 b)

y

H

W ^x 6

4 5

7 8 6

7 4 5

3

2 3 2

Figure 2: Mutually conflicting sets

seq_i2 ≥...≥ seq_ik and the summation over the widths of the corresponding items is strictly larger than W (for the sake of simplicity, it is assumed that the ij’s are all different). Since variabley_i1t1 is conflicting withy_i2t2, the required width for the two corresponding items is w_i1+w_i2. The same applies to y_i3t3 which is conflicting with yi1t1 and yi2t2, thus requiring a width of wi1 +wi2 +wi3. Following the same line of reasoning, the required width is Pk

j=1w_ij which is strictly larger than W (by hypothesis). This observation contradicts the fact that the 2OPP-UL solution is feasible. This proof can be easily extended to the case where the ij’s are not all different.

These observations led to the conflict inequalities which are descried in the next section.

4.1 Conflict inequalities

Let us consider the following proposition:

Proposition 4.2 In every feasible 2OPP-UL solution, we have:

X

yit∈C

w_iy_it≤W ∀C∈ Y such that X

i∈I(C)

w_i > W, (15)

where Y is the set of all mutually conflicting subsets of Y. Inequalities (15) are classical knapsack constraints. For any given mutually conflicting set C, we can instead use the followingcover inequality:

X

yit∈C

y_it≤ |I(C)| −1 (16)

whereI(C) is the set of items associated with the variables inC. One can observe that inequality (16) is a special case of the classicalGUB cover inequality. We recall thatC is a GUB cover ifP

i∈I(C)wi > W and if no two variables are associated with the same item. SetCcan be transformed into a GUB cover by removing all variables but one that belong to the same item. In addition, setC is a minimal GUB cover if no proper subset ofC is a GUB cover. Assuming thatC is both mutually conflicting and a minimal GUB cover, we can consider an extension E such that C ⊆E,E is mutually conflicting and max_i∈I(C){wi} ≤ min_{i∈I(E)\I(C)}{wi}. Inequality (16) can then be extended and dominated by:

X

yit∈E

y_it≤ |I(C)| −1 (17)

We prefer here to use a special type of GUB lifted cover inequality because a single weightw_i is associated with they_it variables, for any given item i. Let C be a minimal GUB cover andE be a mutually conflicting set such that C ⊆E. Then we can derive the following inequality:

X

yit∈E,i∈I(C)

y_it+ X

yit∈E,i6∈I(C)

α_iy_it≤ |I(C)| −1 (18) We will refer to the α_i’s as the lifting coefficients. They can be computed by solving a series of knapsack problems [17]. We will refer to these inequalities as conflict inequalities.

4.2 Max flow inequalities

Another type of inequality is obtained by considering any mutually conflicting set C such that P

i∈I(C)w_i ≤W. For example, let us assume that items 1, 5 and 6 in Figure 3 are fixed at their current position. Then, we can identify the feasible areas for all other items. For example, the items to be delivered after 1 but before 5 must be in areasA₁, B₅, B₆ orE.

Let t^min_i = min_yjt∈C{t :j = i} and t^max_i = max_yjt∈C{t :j = i}. A maximum flow problem, defined on an appropriate network, can be solved to know if the remaining free items can lead to a feasible solution given that the items associated with setC are fixed at their current position. More precisely, the network would be as follow:

• a source nodes,

• a destination node t,

• for eachi∈I(C), nodesA_i andB_i, whereA_i stands for the area immediately under item iand Bi for the area immediately above it,

E

y

H

Wx 0

1 5 6 B6 B5

A1 B1

A6 A5

Figure 3: Areas associated with mutually conflicting sets

• a nodeE for the remaining area,

• for each i∈I\I(C), a nodeki,

• for each i∈I(C), an arc fromstoA_i with a capacity equal to t^max_i w_i,

• for eachi∈I(C), an arc fromstoBiwith a capacity equal to (H−t^min_i −hi)wi,

• an arc from stoE with a capacity equal to H(W −P

i∈I(C)w_i),

• for each i∈I(C) and j∈I\I(C), an arc fromA_i tok_j with a capacity equal to min{wi, w_j}hj ifh_j ≤t^max_i and seq_i≤seq_j,

• for each i∈I(C) and j∈I\I(C), an arc fromB_i tok_j with a capacity equal to min{wi, wj}hj ifhj ≤H−t^min_i −hi and seqi ≥seqj,

• for eachi∈I\I(C), an arc fromEtok_iwith a capacity equal tomin{wi, W− P

i∈I(C)w_i}hi

• for each i∈I\I(C), an arc fromk_i totwith a capacity equal to h_iw_i.

Let maxf low(C) be the maximum flow from s to t in this network. We then have :

Proposition 4.3 If maxf low(C) is strictly smaller than P

i∈I\I(C)h_iw_i then the mutually conflicting set C leads to an infeasible solution. The partial solution can be forbidden through the following constraints:

X

yit∈C

y_it≤ |I(C)| −1 ∀C ∈ Y such that maxf low(C)< X

i∈I\I(C)

h_iw_i (19)

We will refer to these inequalities as the max flow inequalities.

4.3 Separation procedures

In the previous section, we introduced some properties of feasible 2OPP-UL so- lutions. In many cases, the 1CBP solution given to the x-check problem will not satisfy these properties. It is thus useful to look for a violated property before calling thex-check problem. The inequality generated from a violated property will also be stronger as it will focus on what truly makes the solution infeasible. Accordingly, at each node of our branch-and-cut algorithm, we first check if the current solution violates inequalities (15) or (19).

A simple heuristic and an exact method have been developed to separate violated inequalities. Given that these inequalities are based on mutually conflicting sets, the first algorithm generates conflicting sets in a heuristic way, while the second one generates all of them.

Starting with an empty set, the heuristic first adds a randomly chosen variable to this set. Then, at each iteration, a new randomly chosen variable in considered and added to the set if it is conflicting with the other variables already in the set.

At the end, we check if the resulting set violates a conflict inequality. If this is the case, the mutually conflicting set is kept. The method is called ntimes, where nis the number of items.

The exact method generates all mutually conflicting sets using a tree search- based algorithm. First, they_itvariables are sorted in ascending order based on item indexiand height positiont. LetOrd(yit) be the order of variabley_it. At the root node, for which there is no mutually conflicting set, a child node is created for each variable and the associated conflicting set is a singleton with only this variable. In subsequent nodes, a new variable is added to the set only if it is of higher order than any variable in the set and if the variable is in conflict with all variables in the set.

Each mutually conflicting set produced in this way is checked to see if it violates an inequality. If it does, the conflicting set is kept.

If the number of variables with a positive value is high, there might just be too many mutually conflicting sets. Based on preliminary experiments, the exact method is called only if this number is smaller than or equal to 1.1 times the number of itemsn. Otherwise, the heuristic method is used. Note also that each inequality must be violated by a value greater than or equal to 0.2 and that a maximum of 10 inequalities are added at each call.

The resulting inequalities are strengthened before they are added to the model.

For a conflict inequality of type (15), a corresponding inequality of type (18) is added as it cuts fractional parts of the feasible domain. To generate an inequality of type (18) from an inequality of type (15), set C is first transformed into a minimal GUB cover by removing the variables with the largest weights. Then, variables with a positive value that are in conflict with all variables already in C are added to the set (considering these variables first proved to generate stronger inequalities).

Then, the same procedure is applied to the remaining variables. We then find the

lifting coefficientsfor the resulting extension by solving a series ofknapsack problems (see [21] for details). As previously mentioned, only one extension is created by considering the variables to be added toC in random order.

For a max-flow inequality (19), the extensionE ={y_it ∈Y :i∈I(C) and t^min_i ≤ t ≤ t^max_i } is used. That is, only the variables associated with the items that are already in C and such thatt is betweent^min_i and t^max_i are considered.

5 Preprocessing

In this section, the various procedures that are applied during the initial prepro- cessing phase are described.

5.1 Height position restrictions

If the first items to be delivered are at the bottom of the bin, the corresponding solution is likely to be infeasible due to the unloading constraints. Figure 4 a) shows that the items to be delivered before itemi must necessarily be in areas B and C.

That is, if they are in area A, item i must be moved to get to these items, which is forbidden. Similarly, the items to be delivered after imust be in areasA and C.

Figure 4 b) shows that if itemiis at some height positiony_i ∈[0, H], the unloading constraints might force some items outside of the bin (we recall that the height position of an item is defined as the height position of its bottom-left corner).

i y1

A

C

W ^x H

y

0 W

y H

0

b)

x a)

B B

i

Figure 4: Height position restrictions

Motivated by some lower bounds reported in [9], we definey_i^minand y^max_i as the minimal and maximal height positions of item i∈I :

y^min,1_i = max















Σ^>,W_(i) ^−wi W









, max

j∈I_i^>,W−wi

{hj}







(20)

y^min,2_i =

&[Σ^>_(i)−H(W −w_i) +P

j∈I_i^≤,wih_j(w_j−w_i)]⁺ w_i

'

(21)

y_i^max,1=H−max















Σ^<,W_(i) ^−wi W









, max

j∈I_i^<,W−wi

{hj}







(22)

y_i^max,2=H−

&[Σ^<_(i)−H(W −wi) +P

j∈I_i^≥,wihj(wj −wi)]⁺ w_i

'

(23)

y_i^min= max{y_i^min,1, y_i^min,2} (24)

y_i^max= min{y^max,1_i , y_i^max,2} (25) Equations (20) and (21) are obtained by considering only the items that must lie below some itemi. More precisely, the valuey_i^min,1corresponds to the maximum between a continuous relaxation over all items that must lie belowiand the item of maximum height that must also lie belowi. The valuey_i^min,2 is the height position obtained by pushing itemidownward as long as the bottom of the bin is not reached or an item in area A, by moving to area C, does not force an item outside of the bin. Similar values in equations (22) and (23) are obtained by considering the items that must lie abovei.

The obtained valuesy^min_i and y_i^max in equations (24) and (25) can be improved in two different ways. First, by considering items that cannot be beside i. Let us suppose, for example, that item j is to be delivered after iand that w_i+w_j > W. In this case, y^min_j +hj is clearly a lower bound ony_i^min. The second improvement can be obtained by considering only normal patterns. In fact, the valuey_i^min should be the minimum height position of itemionly if it corresponds to a normal pattern (i.e., the bottom of item i touches the top of another item or the bottom of the bin). If this is not the case, it can be reset to the minimum height position larger than y^min_i which corresponds to a normal pattern. The same line of reasoning can be applied to y^max_i . We thus obtain:

y^min_i = max{y_i^min,1, y^min,2_i , max

j∈I_i^>,W−wi

{y_j^min+h_j}, min{t:t∈P_i^H}} (26)

y^max_i = min{y^max,1_i , y_i^max,2, min

j∈I_i^<,W−wi

{y^max_j −h_i}, max{t:t∈P_i^H}} (27)

5.2 Lifting

As shown by previous authors [2, 6], if we do not find any combination of widths such that their sum is equal to W, then it is possible to reduce the width W as some unused space will remain. The same idea can be applied to the heightH. The values W^∗ and H^∗ in equations (28) and (29) can be obtained through dynamic programming. At the end, we resetW toW^∗ and H toH^∗.

W^∗= max{X

i∈I

z_iw_i:X

i∈I

z_iw_i ≤W, z_i∈ {0,1}, i∈I} (28) H^∗ = max{X

i∈I

zihi :X

i∈I

zihi ≤H, zi ∈ {0,1}, i∈I} (29) A similar procedure can then be applied to the item sizes. The increase in width and height of itemi∈I is given by the following equations:

∆w_i =W −max{wi− X

j∈I\{i}

z_jw_j : X

j∈I\{i}

z_jw_j ≤W −w_i, z_j ∈ {0,1}, j∈I\{i}}

(30)

∆h_i =H−max{hi− X

j∈I\{i}

z_jh_j : X

j∈I\{i}

z_jh_j ≤H−hi, z_j ∈ {0,1}, j∈I\{i}} (31) Clearly, not all items can be found at a given height position t ∈ P^H, either because it is not part of their normal patterns or becausey_i^min is too large or y^max_i is too small for some itemi∈I. Thus, it might well happen that the width occupied by the set of remaining items I^t at height position t can only be smaller than W. In this case, we can further reduce the widthW toW_t :

W_t= max{X

i∈I^t

z_iw_i:X

i∈I^t

z_iw_i≤W :z_i∈ {0,1}, i∈I^t} t∈P^H (32) We can extend this line of reasoning to individual items. Let us assume that item iis at height positiont. Then, we can consider the other items one by one and use the previously described maximum flow algorithm to detect if it can be beside item i or not (see section 4.2). After removing all items that cannot be beside i, there might always be an empty space besidei. In this case, we can increase the width of w_i tow_it to cover the empty space. The w_it values can be obtained by solving (in pseudo-polynomial time) subset sum-like problems using dynamic programming.

5.3 Precedence relations

Let us consider itemsiand j such thatiis delivered after j (i.e., seq_i > seq_j). We want to know if there is a feasible solution where height position tj is smaller than t_i. If there is no such solution, we have a precedence relation between items i and j, because the height position of imust be smaller than or equal to the the height position ofj for a solution to be feasible.

Formally, we identify two different types of precedence relations : a weak prece- dence relation where t_i ≤ t_j and a strong precedence relation where t_i +h_i ≤ t_j. Furthermore, we consider a side-by-side relation where t_i ≤ t_j < t_i +h_i or t_j ≤ ti < tj +hj always holds. The sets of weak precedence, strong precedence and side-by-side relation associated with item i are denoted H(i)⁻, H(i)⁺ and H(i)⁼, respectively.

In the following, we present conditions for such precedence relations to occur between items iand j.

Condition 1 : Ify_i^max+h_i ≤y_j^min, thenj∈H⁺(i).

Condition 2 : Ify_i^max≤y^min_j thenj∈H⁻(i).

Condition 3 : If maxf low(C)<P

k∈I\{i,j}h_kw_k for allt_i ∈ P_i^H and t_j ∈P_j^H such thatt_j < t_i and C={yiti, y_jtj}is a mutually conflicting set, then j∈H⁻(i).

Condition 4 : Ifw_i+w_j > W, thenj∈H⁺(i)..

Condition 5 : If maxf low(C)<P

k∈I\{i,j}h_kw_k for allt_i ∈ P_i^H and t_j ∈P_j^H such that t_j < t_i+h_i and C = {yiti, y_jtj} is a mutually conflicting set, then j ∈ H⁺(i).

Condition 6 : If maxf low(C)<P

k∈I\{i,j}hkwk for allti ∈P_i^H and tj ∈P_j^H such that t_i > t_j or t_i < t_j and C = {yiti, y_jtj} is a mutually conflicting set, then j∈H⁼(i).

From Conditions 1 to 3, we obtain inequalities (33) where the height position of itemj is forced to be greater than or equal to the height position of item i, wheni is weakly precedingj. From Conditions 4 and 5, we get inequalities (34) where the height position of itemj is forced to be greater than or equal to the height position of item i plus its height h_i, when i is strongly preceding j. Finally, Condition 6 leads to inequalities (35) where items iand j are forced to be side-by-side.

y_it ≤ X

¯t∈P_j^H

¯t≥t

yj¯t i∈I, j ∈H⁻(i), t∈P_i^H (33)

y_it≤ X

¯t∈P_j^H

¯t≥t+hi

y_j¯t i∈I, j ∈H⁺(i), t∈P_i^H (34)

y_it≤ X

¯t∈P_j^H(t)

y_j¯t i∈I, j ∈H⁼(i), t∈P_i^H, (35)

5.4 Reconsidering the normal patterns

In this section, we describe two different ways of reducing the initial set of normal patterns.

5.4.1 Normal pattern dominance

It is possible to reduce the set of normal patterns by considering a dominance relation among the patterns associated with a given item. Letibe an item andt_i ∈P_i^H some height position corresponding to a pattern. If iis at height positionti and nothing fits over i, then nothing will fit over i at any height positiont > t_i. Let t^min_i ∈P_i^H be the lowest height position such that nothing fits over item i. Then every height position t∈P_i^H such that t≥t^min_i can be removed. This type of relation is called Normal Pattern Dominance.

5.4.2 Normal pattern reduction

Previously, we introduced a feasibility test based on the solution of a maximum flow problem to know if a partial solution based on a mutually conflicting set of items leads to an infeasible solution. This test can also be used to prove the feasibility of a normal pattern. Suppose that itemiis at height position t_i∈P_i^H. If all mutually conflicting sets that include t_i fail the feasibility test then t_i can be removed from P_i^H. But since there might be a huge number of mutually conflicting sets, a more viable approach is the following. For any given itemiand height positiont_i ∈P_i^H,t_i can be removed fromP_i^H if there is an itemjsuch that for allt_j ∈P_j^H and mutually conflicting set C = {yiti, yjtj}, maxf low(C) is smaller than P

k∈I\{i,j}hkwk. The value t_i is then added to a set IN F_i that contains infeasible height positions for itemi.

By using the previously defined y^min_i values, y^max_i values and IN F_i sets, an improved procedure can be designed to calculate a reduced set of normal patterns.

The pseudo-code of this procedure is found in Algorithm 1 for the typical case where the bin is filled from the bottom to the top.

The normal patterns are generated by a call to the method Calculate Normal Patterns. Three sets Cur,Prev and Glob are first initialized with position 0 which is the bottom of the bin. Set P rev contains all normal patterns generated up to (but not including) the current customer j. Note that Curis reset to P rev before generating the patterns of each item associated with customer j. The patterns

for item i ∈ I_j are generated recursively by the method Generate Patterns if the current customer has more than one item. When the set of all patterns associated with itemihas been produced, the global variableP_i^H is assigned with this set. The newly generated patterns are also added to setGlob. When all items of the current customer are done,P rev is set toGlobjust before handling the next customer. The methodsGenerate Patterns andGenerate Patterns Recursively consider all possible ordered combinations of items in setIand make sure that the corresponding patterns are feasible normal patterns.

The complexity of this algorithm is O(Hn(o−1)!) whereH is the height of the bin, n is the number of items and o = max_j=1,...,R|I_j|. The algorithm performs well when the number of items per customer is small. However, if (o−1)! is larger thann, it is better to use the dynamic algorithm based on equations (1) and (2), as reported in [18], which is in the order of O(Hn²).

Algorithm 1 Calculate Normal Patterns Require: y_i^min, y_i^max and IN Fi

P rev ← {0}

Cur← {0}

Glob← {0}

for j=R to 1 do fori∈I_j do

Cur←P rev if I_j\{i} 6=∅ then

Generate Patterns(Ij\{i}, Cur) end if

P_i^H ← {t∈Cur\IN Fi:y_i^min ≤t≤y^max_i } fort∈P_i^H do

Cur←Cur∪ {t+h_i} end for

Glob←Glob∪Cur end for

P rev←Glob end for

5.5 Top-fill versus bottom-fill

Typically, a bottom-left approach is used to generate the set of normal patterns (as in Algorithm 1). More precisely, the bottom of every item must be in contact with either the bottom of the bin or the top of another item. Furthermore, the left side of each item must be in contact with the left side of the bin or the right side of another item.

Due to the unloading constraints, solutions to our problem exhibit a special

Algorithm 2 Generate Patterns

Require: I : set of items,P : set of patterns min_y ←min

i∈I y_i^min max_y ←max

i∈I y^max_i

for t=max_y tomin_y do if t∈P then

fori∈I do

Generate Patterns Recursively(t+h_i, I\{i}, P) end for

end if end for

Algorithm 3 Generate Patterns Recursively

Require: t: a starting position,I : set of items, P : set of patterns if t∈P then

Exit end if P ←P∪ {t}

for i∈I do

if y_i^min≤t≤y_i^max and t6∈IN F_i then

Generate Patterns Recursively(t+hi, I\{i}, P) end if

end for

structure which can be exploited by choosing to fill the bin from the bottom, from the top or from both the bottom and the top (mixed fill), in the hope of reducing the set of normal patterns. With regard to the mixed approach, if the items with delivery orderj(customerj) fill the bin from the bottom, then the items with delivery order k(customerk) withk > jalso fill the bin from the bottom. Conversely, if the items with delivery orderj fill the bin from the top, then the items with delivery order k withk < j also fill the bin from the top.

For a sequence of R customers, there are R+ 1 ways to choose the cut point between the customers whose items will fill the bin from the bottom and the cus- tomers whose items will fill the bin from the top. It is then possible to choose, among theseR+ 1 cut points, the one that leads to the smallest number of normal patterns. Figure 5 presents an example of a mixed fill where the cut point is chosen between customers 3 and 4, that is, items of customers 1, 2 and 3 fill the bin from the top and items of customers 4, 5 and 6 fill the bin from the bottom.

5

0 W ^x

H y

4 3 2

5

6 1

1

4

Figure 5: Mixed Fill

Proposition 5.1 If a solution is feasible for a given cut point, it is feasible for every cut point.

Proof. Let us assume that a feasible solutions₁ is obtained when the cut point is in position 1, that is, just before the first customer (which corresponds to filling the bin from the bottom, as it is typically done). Then, a feasible solution s₂ for the cut point in position 2, i.e. between customers 1 and 2, is obtained froms₁ by pushing the items of customer 1 up until the top of the bin is reached. Similarly, a feasible solution s₃ for the cut point in position 3, i.e. between customers 2 and 3, is obtained from s₂ by pushing the items of customer 2 up until the top of the bin or the bottom of another item is reached. The result is obtained by repeating this argument until the cut point is in position R+ 1.

This proposition also means that if a solution is infeasible for a given cut point, it is infeasible for every cut point. Thus, we are guaranteed not to miss any feasible solution. As indicated in the demonstration of the above proposition, there might also be a gap between the top-filled and bottom-filled items. Inspired by the work in [6], a constraint is associated with each item and each height position to force down (up) a top-filled item so that its bottom (top) touches another item which must be delivered after (before) it. These constraints are the following:

yit ≤

R

X

j=seqi

X

k∈Ij

k6=j

y_k(t−hk) t∈P_i^H, i∈I and iis bottom-filled (36)

y_it≤

seqi

X

j=1

X

k∈Ij

k6=j

y_k(t+hk) t∈P_i^H, i∈I and iis top-filled (37)

6 Lower bounds

In this section we present some lower bounds on the required height of the bin.

6.1 Simple Lower Bounds

First, we can use the lower bound for the SPP reported in [23]. This so-called continuous lower bound, denoted L₁, calculates the number of strips of width W and height 1 needed to accommodate all items.

L₁ = P

i∈Iw_ih_i W

(38) From the definition of y_i^min and y^max_i in equations (26) and (27), the following lower bound can also be derived:

L₂ = max

i∈P{y^min_i +h_i+ (H−y_i^max)} (39)

It is worth noting that this bound improves upon the one reported in [9], through the addition of the third term in the numerator of y_i^min,2 and y^max,2_i in equations (21) and (23) and through the consideration of the third and fourth components in the definition of y^min_i andy_i^max in equations (26) and (27).

6.2 Lower Bounds based on the Cutting Stock Problem

The bounds presented in this section are based on the Gilmore-Gomory formulation of the Cutting Stock Problem (CSP). We define a cutting pattern as a subset of items I⁰ ⊂ I. A pattern is said to be h-feasible if P

i∈I⁰h_i ≤ H and w-feasible if P

i∈I⁰w_i ≤W. Let K^H and K^W be the sets of all h-feasible andw-feasible cutting patterns. Let also the variable v_k be equal to the number of times cutting pattern k appears in a solution with a_ik = 1 if item i is in cutting pattern k, 0 otherwise.

The CSP based onw-feasible cutting patterns (CSP^W) can be formulated as follow :

(CSP^W) min X

k∈K^W

v_k (40)

X

k∈K^W

a_ikv_k≥h_i i∈I (41)

v_k≥0 and integer k∈ K^W (42) The optimal solution value of (CSP^W) provides a lower bound on the required height of the bin. Thus, an instance is infeasible if the obtained value is larger than H. ACSP^H can be defined similarly to obtain a lower bound on the required width.

We will call these two lower bounds L^H₃ and L^W₃ , respectively.

The CSP is famous for the strength of its linear relaxation and it is often the case that the round up value of the linear relaxation is optimal. Column (cutting pattern) generation is typically used to solve this problem and it is well known that the pricing subproblem is a knapsack problem (KP), where the item values come from the dual variables. We refer to [4] for more details on this issue in the context of the 2OPP. A column of negative reduced cost generated at a given width or height position often corresponds to subsets of items that cannot be side by side or one over the other because the corresponding KP does not account for any unloading structure. Clearly, integrating some unloading structure can only improveL^W₃ and L^H₃ .

For example, we can improve L^H₃ to obtain L^H₄ by considering only the items i ∈ I that can be at some height position, based on the current set P^H and the valuesy_i^min and y^max_i . Although we might still end up with infeasible columns, this approach has proven to be very effective.

We can also improveL^W₃ to obtainL^W₄ . Here, we must generate a feasiblestack of items of negative reduced cost at some width position, as illustrated in Figure 6.

For generating stacks, an algorithm similar in spirit to the one used for generating normal patterns is applied (see section 5.4). LetV(j, h) be the sum of the item values over all items that are below position h in an optimal stack for customers with a delivery order between j and R. Also, let S be a subset of items associated with