Generating unconstrained two-dimensional non-guillotine cutting patterns by a recursive partitioning algorithm Ernesto G. Birgin ∗ Rafael D. Lobato ∗ Reinaldo Morabito † April 3, 2010 ‡ Abstract In this study, a dynamic programming approach to deal with the unconstrained two- dimensional non-guillotine cutting problem is presented. The method extends the recently introduced recursive partitioning approach for the manufacturer’s pallet loading problem. The approach involves two phases and uses bounds based on unconstrained two-staged and non-staged guillotine cutting. The method is able to find the optimal cutting pattern of a large number of problem instances of moderate sizes known in the literature and a coun- terexample for which the approach fails to find known optimal solutions was not found. For the instances that the required computer runtime is excessive, the approach is combined with simple heuristics to reduce its running time. Detailed numerical experiments show the reliability of the method. Key words: Cutting and packing, two-dimensional non-guillotine cutting pattern, dynamic programming, recursive approach, distributor’s pallet loading problem. 1 Introduction In the present paper, we study the generation of two-dimensional non-guillotine cutting (or packing) patterns, also referred by some authors as two-dimensional knapsack problem or two-dimensional distributor’s pallet loading. This problem is classified as 2/B/O/ according to Dyckhoff’s typology of cutting and packing problems [21], and as two-dimensional rectangular Single Large Object Packing Problem (SLOPP) based on Waescher et al.’s typology [47]. Besides the inherent complexity of this problem (it is NP-hard [7]), we are also motivated by its practical relevance in different industrial and logistics settings, such as in the cutting of steel and glass stock plates into required sizes, the cutting of wood sheets and textile materials to make ordered pieces, the loading of different items on the pallet surface or the loading of different pallets on the truck or container floor, the cutting of cardboards into boxes, the placing of advertisements on ∗ Department of Computer Science, Institute of Mathematics and Statistics, University of S˜ao Paulo, Rua do Mat˜ao 1010, Cidade Universit´aria, 05508-090 S˜ao Paulo, SP - Brazil. e-mail: {egbirgin|lobato}@ime.usp.br † Department of Production Engineering, Federal University of S˜ao Carlos, Via Washington Luiz km. 235, 13565-905, S˜ao Carlos, SP - Brazil. e-mail: [email protected]‡ Revised on August 20, 2010. 1
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Ernesto G. Birgin ∗ Rafael D. Lobato ∗ Reinaldo Morabito †
April 3, 2010‡
Abstract
In this study, a dynamic programming approach to deal with the unconstrained two-dimensional non-guillotine cutting problem is presented. The method extends the recentlyintroduced recursive partitioning approach for the manufacturer’s pallet loading problem.The approach involves two phases and uses bounds based on unconstrained two-staged andnon-staged guillotine cutting. The method is able to find the optimal cutting pattern of alarge number of problem instances of moderate sizes known in the literature and a coun-terexample for which the approach fails to find known optimal solutions was not found. Forthe instances that the required computer runtime is excessive, the approach is combinedwith simple heuristics to reduce its running time. Detailed numerical experiments show thereliability of the method.
In the present paper, we study the generation of two-dimensional non-guillotine cutting(or packing) patterns, also referred by some authors as two-dimensional knapsack problem ortwo-dimensional distributor’s pallet loading. This problem is classified as 2/B/O/ according toDyckhoff’s typology of cutting and packing problems [21], and as two-dimensional rectangularSingle Large Object Packing Problem (SLOPP) based on Waescher et al.’s typology [47]. Besidesthe inherent complexity of this problem (it is NP-hard [7]), we are also motivated by its practicalrelevance in different industrial and logistics settings, such as in the cutting of steel and glassstock plates into required sizes, the cutting of wood sheets and textile materials to make orderedpieces, the loading of different items on the pallet surface or the loading of different pallets on thetruck or container floor, the cutting of cardboards into boxes, the placing of advertisements on
∗Department of Computer Science, Institute of Mathematics and Statistics, University of Sao Paulo, Rua doMatao 1010, Cidade Universitaria, 05508-090 Sao Paulo, SP - Brazil. e-mail: {egbirgin|lobato}@ime.usp.br
†Department of Production Engineering, Federal University of Sao Carlos, Via Washington Luiz km. 235,13565-905, Sao Carlos, SP - Brazil. e-mail: [email protected]
‡Revised on August 20, 2010.
1
the pages of newspapers and magazines, the positioning of components on chips when designingintegrated circuit, among others.
Given a large rectangle of length L and width W (i.e. a stock plate), and a set of rectangularpieces grouped into m different types of length li, width wi and value vi, i = 1, . . . , m (i.e. theordered items), the problem is to find a cutting (packing) pattern which maximizes the sum ofthe values of the pieces cut (packed). The cutting pattern is referred as two-dimensional sinceit involves two relevant dimensions, the lengths and widths of the plate and pieces. A feasibletwo-dimensional pattern for the problem is one in which the pieces placed into the plate do notoverlap each other, they have to be entirely inside the plate, and each piece must have one edgeparallel to one edge of the plate (i.e., an orthogonal pattern). In this paper we assume thatthere are no imposed lower or upper bounds on the number of times that each type of piece canbe cut from the plate; therefore, the two-dimensional pattern is called unconstrained (i.e., 0 and⌊
Lli
⌋⌊
Wwi
⌋
turn out to be the obvious minimum and maximum number of pieces of type i in thepattern); otherwise, it would be called constrained or doubly-constrained.
Without loss of generality, we also assume that the cuts are infinitely thin (otherwise weconsider that the saw thickness was added to L, W , li, wi), the orientation of the pieces is fixed(i.e., a piece of size (li, wi) is different from a piece of size (wi, li) if li 6= wi) and that L, W ,li, wi are positive integers. We note that if the 90◦-rotation is allowed for cutting or packingthe piece type i of size (li, wi), this situation can be handled by simply considering a fictitiouspiece type m + i of size (wi, li) in the list of ordered items, since the pattern is unconstrained.Depending on the values vi, the pattern is called unweighted, if vi = γliwi for i = 1, . . . , m andγ > 0 (i.e., proportional to the area of the piece), or weighted, otherwise.
Moreover, we assume that the unconstrained two-dimensional cutting pattern is non-guillotineas it is not limited by the guillotine type cuts imposed by some cutting machines (an orthogonalguillotine cut on a rectangle is a cut from one edge of the rectangle to the opposite edge, parallelto the remaining edge). Some industrial cutting processes also limit the way of producing aguillotine cutting pattern. At a first stage the cuts are performed parallel to one side of theplate and then, at the next stage, orthogonal to the preceding cuts, and so on. If there is animposed limit on the number of stages, say k, the guillotine pattern is called a k-staged pat-tern; otherwise, it is non-staged (note that a non-staged pattern is equivalent to define k largeenough).
A large number of studies in the literature have considered staged and non-staged two-dimensional guillotine cutting problems. Much less studies have considered two-dimensionalnon-guillotine cutting problems (constrained and unconstrained), and only a few of them haveproposed exact methods to generate non-guillotine patterns. For example, [6] and [28] presented0–1 linear programming formulations for the problem using 0–1 decision variables for the posi-tions of the pieces cut from the plate; they developed Lagrangean relaxations and used them asbounds in tree search procedures (subgradient optimization was used to optimize the bounds).In [46] and [16], the problem is formulated as 0–1 linear models using left, right, top and bot-tom decision variables for the relative positions of each pair of pieces cut from the plate (withmultiple choice disjunctive constraints); they suggested solving the models by branch-and-boundalgorithms exploring particular structures of these constraints. Other related 0–1 linear formula-tions appear in [14, 22], and a 0–1 non-linear formulation was presented in [7] (see also [44, 42]).Other exact and branch-and-bound approaches based on the so called two-level approach (the
2
first level selects the set of pieces to be cut without taking into account the layout, the secondchecks whether a feasible cutting layout exists for the pieces selected) are found in [15, 4, 24].The method presented in [24] is based on a two-level tree search that combines the use of aspecial data structure for characterizing feasible cuttings with upper bounds.
Different heuristics based on random local search, bottom-left placement, network flow, graphsearch, etc., and different metaheuristics based on genetic algorithms, tabu search, simulatedannealing, GRASP, etc., for generating constrained and unconstrained two-dimensional non-guillotine cuttings are found in the literature. Some recent examples are in [2, 27, 35, 17, 13,22, 48]. Nonlinear-programming-based method for packing rectangles within arbitrary convexregions, considering different types of positioning constraints, were presented in [10, 11, 8, 38].
Most of these approaches were developed for the constrained problem, which can be moreinteresting for certain practical applications with relatively low demands of the ordered items.However, part of these methods may not perform well when solving the unconstrained problem,especially those whose computational performance is highly dependent on the total number ofordered items. On the other hand, the unconstrained problem is particularly interesting forcutting stock applications with large-scale production and weakly heterogeneous items (i.e.,relatively few piece types but many copies per type), in which the problem plays the role of acolumn generation procedure, as pointed out by several authors since the pioneer study in [26].
In the present paper we extend a Recursive Partitioning Approach presented in [9] for themanufacturer’s pallet loading to deal with the unconstrained two-dimensional orthogonal non-guillotine cutting (unweighted and weighted, without and with piece rotation). This RecursivePartitioning Approach combines refined versions of both the Recursive Five-block Heuristic pre-sented in [40, 41] and the L-approach for cutting rectangles from larger rectangles and L-shapedpieces presented in [37, 12]). This combined approach also uses bounds based on unconstrainedtwo-staged and non-staged guillotine cutting patterns. The approach was able to find an optimalsolution of a large number of problem instances of moderate sizes known in the literature and wewere unable to find an instance for which the approach fails to find a known or proved optimalsolution. For the instances that the required computer runtimes were excessive, we combinedthe approach with simple heuristics to reduce its running time.
The paper is organized as follows. In Section 2 we briefly review a 0–1 linear programmingformulation of the problem and some lower and upper bounds known in the literature. InSection 3 we present the two phases of the Recursive Partitioning Approach and some heuristicsthat reduce the time and memory requirements of the procedure to deal with large probleminstances. Then in Section 4 we analyze the computational performance of the approach, withand without the heuristics, in some numerical experiments. Finally, in Section 5 we present theconcluding remarks of this study.
2 Problem modeling and bounds
2.1 Problem modeling
The unconstrained two-dimensional non-guillotine cutting problem can be modeled as a 0–1linear formulation proposed in [6]. Let (x, y) be the coordinates of the left-lower-corner of apiece placed on the plate of size (L, W ) (for simplicity we assume that the left-lower-corner of
3
the plate is (0, 0)). Without loss of generality, it can be shown that x and y belong, respectively,to the sets of conic combinations of li and wi, i = 1, . . . , m, for L and W , defined by:
SL = {x ∈ Z+ | x =
m∑
i=1
rili, 0 ≤ x ≤ L, ri ∈ Z+, i = 1, . . . , m} and
SW = {y ∈ Z+ | y =m
∑
i=1
siwi, 0 ≤ y ≤W, si ∈ Z+, i = 1, . . . , m}.
Note that as we decide to place a piece of type i in a position (x, y), we cannot place anotherpiece in a position (x′, y′) such that x ≤ x′ ≤ x + li − 1 and y ≤ y′ ≤ y + wi − 1, x, x′ ∈ SL,y, y′ ∈ SW . In order to avoid piece overlapping, let gixyx′y′ be the mapping:
gixyx′y′ =
{
1, if x ≤ x′ ≤ x + li − 1 and y ≤ y′ ≤ y + wi − 1,0, otherwise,
which can be computed a priori for each i, (x, y) and (x′, y′). By defining the decision variablesaixy, i = 1, . . . , m, x ∈ SL, y ∈ SW , as:
aixy =
{
1, if a piece of type i is placed in a position (x, y),0, otherwise,
the model can be formulated as the following 0–1 integer program:
maxm
∑
i=1
∑
x∈SL
∑
y∈SW
viaixy (1)
subject tom
∑
i=1
∑
x∈SL
∑
y∈SW
gixyx′y′aixy ≤ 1, x′ ∈ SL, y′ ∈ SW , (2)
aixy ∈ {0, 1}, i = 1, . . . , m, x ∈ SL, y ∈ SW . (3)
Note that model (1–3) has O(m|SL||SW |) 0–1 variables and |SL||SW | constraints1. It can beshown that, without loss of generality, sets SL and SW can be replaced by the smaller sets RL
and RW known as reduced raster points [45] and defined as:
RL = {x ∈ Z+ | x = 〈L− x〉SLfor some x ∈ SL},
RW = {y ∈ Z+ | y = 〈W − y〉SWfor some y ∈ SW },
(4)
where〈x〉SL
= max{x ∈ SL | x ≤ x} and 〈y〉SW= max{y ∈ SW | y ≤ y}.
However, since both SL, SW and RL, RW can be large in practical cases, it may be hard tosolve the model above, as illustrated in Section 4. As mentioned before, other 0–1 linear modelsfor the non-guillotine cutting are found in the literature, but authors have pointed out that theirLP-relaxations provide bounds in general far from the optimal solution values [7, 22].
1By defining SiL = {x ∈ SL|0 ≤ x ≤ L− li} and Si
W = {y ∈ SW |0 ≤ y ≤W − wi}, it is possible to reduce thenumber of binary variables of the model substituting SL and SW by Si
L and SiW , respectively, in the summations
of (1) and (2) and in (3).
4
2.2 Lower and upper bounds
A simple lower bound on the value of an optimal cutting can be obtained from the besthomogeneous packing considering all types of pieces:
maxi∈{1,...,m}
{
vi
⌊
L
li
⌋⌊
W
wi
⌋}
. (5)
Similarly, a simple upper bound on the value of an optimal cutting is given by⌊
LW maxi∈F (L,W )
{
vi
liwi
}⌋
,
where F (L, W ) = {i ∈ {1, . . . , m} | li ≤ L and wi ≤W}.Other lower and upper bounds are found in [6, 43, 25, 7, 2, 4]. However, most of these lower
and upper bounds were proposed for the constrained non-guillotine cutting, and they are lesseffective for the unconstrained problem. In our implementation of the algorithm described inSection 3, we have used the lower bound given by the best homogeneous packing (5) and theupper bound introduced in [25]. According to [25], the upper bound for a rectangle with lengthL and width W considering all types of pieces is given by
min{uh(L, W ), uv(L, W )}, (6)
where
uh(L, W ) =
⌊
W maxt∈Z
m+
{
∑
i∈F (L,W )
vi
wi
ti
∣
∣
∣
∣
∣
∑
i∈F (L,W )
liti ≤ L
}⌋
and
uv(L, W ) =
⌊
L maxt∈Z
m+
{
∑
i∈F (L,W )
vi
liti
∣
∣
∣
∣
∣
∑
i∈F (L,W )
witi ≤W
}⌋
.
Upper bounds for all subproblems can be obtained by solving only two unconstrained knapsackproblems at the beginning of the algorithm. A dynamic programming procedure for solvingthese problems is presented in details in [25].
3 Description of the algorithm
The Recursive Partitioning Algorithm presented here is an extension of the algorithm de-scribed in [9] for the manufacturer’s pallet loading problem. It has basically two phases: inphase 1 it applies a recursive five-block heuristic based on the procedure presented in [40] andin phase 2 it uses an L-approach based on a dynamic programming recursive formula presentedin [37, 12]. Firstly, phase 1 is executed and, if a certificate of optimality is not provided by theRecursive Five-block Heuristic, then phase 2 is executed. Additionally, information obtainedin phase 1 is used in phase 2 in at least two ways, according to [9]. If an optimal solutionwas already found for a subproblem in phase 1, it is not solved again in phase 2, improvingthe performance of phase 2. Moreover, having the information obtained in phase 1 at hand,phase 2 is often able to obtain better lower bounds for its subproblems than the ones providedby homogeneous cuttings (5), therefore improving the performance of phase 2. These two phasesare detailed in the sequel.
5
3.1 Phase 1
In phase 1, the Recursive Five-block Heuristic divides a rectangle into five (or less) smallerrectangles in a way that is called first-order non-guillotine cut [3]. Figure 1 illustrates this kind ofcut represented by a quadruple (x1, x2, y1, y2), such that 0 ≤ x1 ≤ x2 ≤ L and 0 ≤ y1 ≤ y2 ≤W .This cut determines five subrectangles (L1, W1), . . . , (L5, W5) such that L1 = x1, W1 = W − y1,L2 = L − x1, W2 = W − y2, L3 = x2 − x1, W3 = y2 − y1, L4 = x2, W4 = y1, L5 = L − x2 andW5 = y2. Each rectangle is recursively cut unless the (sub)problem related to this rectangle hasalready been solved.
(0, 0)
y1
y2
x1 x2 (0, 0)
12
3
45
L4 L5
L2L1
W1
W4
W2
W5
(a) (b)
Figure 1: Representation of a first-order non-guillotine cut.
A pseudo-code of the Recursive Five-block Algorithm for the unconstrained non-guillotinecutting problem is presented in Algorithms 12 and 2. The method is composed by two proce-dures: Five-block-Algorithm and Solve. The second one is an auxiliary subroutine usedby the first. Input parameters of Five-block-Algorithm include the dimensions of the plateand the pieces, and n and N correspond to the current depth and the maximum depth limit ofthe search, respectively.
In Five-block-Algorithm, the lower bound starts with the value of the best homogeneoussolution (5), and it is updated as better solutions are found by the algorithm. The procedureuses the upper bound (6). Both the initial lower and upper bounds are computed a priori. Inthis way, an optimal solution can be detected in the procedure by closing the gap between thesebounds. Note that without loss of generality, the procedure only considers the sets of rasterpoints as defined in Section 2. Moreover, the same symmetry constraints for both guillotine andfirst-order non-guillotine cuttings considered in [9] are used in the present algorithm to avoidequivalent patterns. As first-order non-guillotine cuts in which a rectangle is cut in exactlythree or four subrectangles can be generated by two or three consecutive guillotine cuts (see [9]for details), only guillotine cuts (lines 18-31) and first-order non-guillotine cuts that generatesexactly five subrectangles (lines 8-17) need to be considered in Algorithm 1.
In the Solve procedure, we note that if the depth limit N is sufficiently large, the Five-block
2It is worth mentioning that there is a minor typographical error in line 13 of Algorithm 2 in [9] (whichcorresponds to Algorithm 1 here), although the computer implementation is correct – the correct constraintshould be y1 < y2 and y2 < W , instead of y1 < y2 and y1 + y2 ≤W .
6
Algorithm 1: Recursive Five-block Algorithm for the unconstrained non-guillotine cuttingproblem.
Input: L,W, l1, w1, v1, . . . , lm, wm, vm, n,N ∈ Z.Output: Value of the best cutting pattern found.Five-block-Algorithm(L,W, l1, w1, v1, . . . , lm, wm, vm, n,N)begin1
zlb ← lowerBound[IL, JW ]2
zub ← upperBound[IL, JW ]3
reachedLimit[IL, JW ]← false4
if zlb = zub then5
return zlb6
Build set RL for L, (l1, . . . , lm), and set RW for W , (w1, . . . , wm)7
foreach x1 ∈ RL such that x1 ≤ ⌊L
2⌋ do8
foreach x2 ∈ RL such that x1 < x2 and x1 + x2 ≤ L do9
Algorithm is able to find the optimal first-order non-guillotine cutting pattern. Otherwise, bychoosing small values of N , it is possible to control the tradeoff between the computer runtimeand the quality of the solution found.
The same subproblem may appear in different levels of the tree search. In the case N is notsufficiently large, a subproblem may be solved more than once (if its solution is not proven to beoptimal) in order to try to improve the previous solution found for it. In this case, if the depthn at which a subproblem is faced is greater than or equal to the depth of its stored solution,
7
Algorithm 2: Subroutine Solve used by Five-block-Algorithm
zi ← Five-block-Algorithm(Li,Wi, l1, w1, v1, . . . , lm, wm, vm, n + 1, N)12
lowerBound[ILi, JWi
]← zi13
depth[ILi, JWi
]← n14
if ¬reachedLimit[ILi, JWi
] then15
upperBound[ILi, JWi
]← zi16
else17
zi ← lowerBound[ILi, JWi
]18
if reachedLimit[ILi, JWi
] then19
reachedLimit[IL, JW ]← true20
Slb ← Slb + zi − zi
lb21
Sub ← Sub + zi − zi
ub22
if zlb ≥ Sub then23
return zlb24
if Slb > zlb then25
zlb ← Slb26
if zlb = zub then27
reachedLimit[IL, JW ]← false28
return zlb29
else30
reachedLimit[IL, JW ]← true31
if Slb > zlb then32
zlb ← Slb33
if zlb = zub then34
reachedLimit[IL, JW ]← false35
return zlb36
return zlb37
end38
the subproblem is not solved again and the stored solution is used. Otherwise, if the currentdepth is smaller, there are two possibilities. If the depth limit N was used to stop the recursionwhen obtaining the stored subproblem solution, then it is worth trying to solve it again. On theother hand, if the depth limit did not interfere in the subproblem resolution, the subproblemwill not be solved again, as a better solution cannot be found. A key subject of the method
8
being proposed is the storage of information of the subproblems previously considered by thealgorithm during the execution. The considered data structure is dynamic and depends on theavailable memory, balancing space and time complexities. Raster points are associated withindices and a combination of arrays and balanced binary search trees is used to store a solutionrepresented by a pair (five-block heuristic) or a quadruple (L-approach) of raster points (see [9](p. 313) for details). In Algorithm 1 (lines 2-4), IX represents the index associated with theraster point X ∈ RL and, analogously, JY represents the index associated with the raster pointY ∈ RW . More explicitly, if the sets of raster points RL and RW are considered ordered sets,the index of a raster point corresponds to its relative position within the set.
Using the same reasoning as in [9] for the manufacturer’s pallet loading, it can be shownthat the worst-case time complexity of the Five-block Heuristic for the unconstrained two-dimensional non-guillotine cutting is O(|RL||RW |(|RL|
2|RW |2 + |SL|+ |SW |) + L + W ) and the
memory complexity is O(|RL||RW |+ L + W ).
3.2 Phase 2
Phase 2 of the Recursive Partitioning Approach applies the L-approach [37, 12, 9] which isbased on the computation of a dynamic programming recursive formula [37]. This proceduredivides a rectangle or an L-shaped piece into two L-shaped pieces. An L-shaped piece is de-termined by a quadruple (X, Y, x, y), with X ≥ x and Y ≥ y, and is defined as the topologicalclosure of the rectangle whose diagonal goes from (0, 0) to (X, Y ) minus the rectangle whosediagonal goes from (x, y) to (X, Y ). Figure 2 depicts the nine possible divisions [9] of a rectangleor an L-shaped piece into two L-shaped pieces.
A pseudo-code of the L-Algorithm for the unconstrained non-guillotine cutting problemis presented in Algorithms 3 and 4. In subroutine Solve-L (Algorithm 4), Li(L, k, ik) andIk(L), for i = 1, 2 and k = 1, . . . , 9, are defined as in [37, 9]. Basically, each set Ik(L), fork = 1, . . . , 9, contains all the pairs or triplets of raster points associated with the cut of type k(the nine cut types are depicted in Figure 2) that divides a rectangle or an L-shaped pieceinto two L-shaped pieces, namely L1(L, k, ik) and L2(L, k, ik). More precisely, L1(L, k, ik) andL2(L, k, ik) represent the normalized L-shaped pieces obtained in the division process. Similarlyto Algorithm 1, input parameters of L-Algorithm include the dimensions of the plate and thepieces, the current depth n and the maximum depth limit N of the search. As Algorithm 1, theL-Algorithm takes into account the storage of information of the subproblems previously solvedduring its execution. The same data structure used in [9] to store this information is used inthe implementation of the present algorithm (a four dimensional array or a combination of anarray and a balanced binary search tree). See [9] for details.
In the L-Algorithm, the lower bound for a rectangle (X, Y ) is given, initially, by the solutionfound in phase 1 for the subproblem (X, Y ). As the algorithm proceeds, the lower bound for thesubproblem (X, Y ) may be improved and updated, so that the lower bound for (X, Y ) in futurerequests is no longer the solution found in the phase 1, but the best solution found so far forthe subproblem (X, Y ). A lower bound for a non-degenerate L-shaped piece can be computedby dividing it into two rectangles and summing up the lower bounds of these two rectangles.The two straightforward different ways of dividing an L-shaped piece into two rectangles areconsidered and the lower bound for the L-shaped piece is given by the best one out of these two
9
(0, 0)
(x, y)
(x′, y′)
(X, Y )
L1
L2
(0, 0)
(x, y)
(x′, y′)
(X, Y )
L1
L2
(0, 0)
(x, y)
(x′, y′)
(X, Y )
L2
L1
B1 B2 B3
(0, 0)
(x, y)
(x′, y′)
(X, Y )
L2L1
(0, 0)
(x, y)
(x′, y′)
(X, Y )
L1
L2
(0, 0)
(x′, y′)
(x′′, y′)
(X, Y )
L1
L2
B4 B5 B6
(0, 0)
(x′, y′′)
(x′, y′)
(X, Y )
L1 L2
(0, 0)
(x, y)
(x′, y′)
(X, Y )
L1
L2
(0, 0)
(x, y)
(x′, y′)
(X, Y )
L1
L2
B7 B8 B9
Figure 2: Subdivisions of an L-shaped piece into two L-shaped pieces.
Algorithm 3: L-Algorithm for the unconstrained non-guillotine cutting problem.
Input: L,W, l1, w1, v1, . . . , lm, wm, vm, n,N ∈ Z.Output: Value of the best cutting pattern found.L-Algorithm(L,W, l1, w1, v1, . . . , lm, wm, vm, n,N)begin1
Build set SL for L, (l1, . . . , lm), and set SW for W , (w1, . . . , wm)2
return Solve-L((L,W,L,W ), SL, SW , 0, N)3
end4
ones. As the algorithm proceeds, the lower bounds for L-shaped pieces are similarly updated asthose for rectangles.
The upper bound for a rectangle (X, Y ) is the same one used in the previous phase, that is,it is computed by (6). The upper bound for a non-degenerate L-shaped piece is given by thearea ratio. Among all pieces that fit into the L-shaped piece, the one with the greatest valueby area ratio is considered. The upper bound for the L-shaped piece is then given by its area
10
Algorithm 4: Subroutine Solve-L used by the L-Algorithm.
Input: An L-shaped piece L (X,Y, x, y), sets SL and SW , and a nonnegative integer N .Output: Value of the best cutting pattern found.Solve-L(L, SL, SW , n,N)begin1
I ← Index(X,Y, x, y)2
if n = N or Solved(I) then3
return solution[I]4
zlb ← L-LowerBound(I)5
zub ← L-UpperBound(I)6
Build set RX for (X,SL), and set RY for (Y, SW )7
foreach k ∈ 1, . . . , 9 do8
foreach ik ∈ Ik(X,Y, x, y) do9
L1 ← L1(L, k, ik)10
L2 ← L2(L, k, ik)11
if L-UpperBound(L1) + L-UpperBound(L2) > zlb then12
z1 ← Solve-L(L1, SL, SW , n + 1, N)13
z2 ← Solve-L(L2, SL, SW , n + 1, N)14
if z1 + z2 > zlb then15
zlb ← z1 + z216
if zlb = zub then17
return zlb18
return zlb19
end20
multiplied by the value per unit area of the most valuable piece, that is,⌊
[XY − (X − x)(Y − y)] maxi∈G(X,Y,x,y)
{
vi
liwi
}
⌋
,
where G(X, Y, x, y) = {i|i ∈ F (X, y) or i ∈ F (x, Y )}.Following the same steps in [9] for the manufacturer’s pallet loading, it can be shown that
the worst-case time complexity of the L-Algorithm for the unconstrained two-dimensional non-guillotine cutting is
O(|RL|2|RW |
2(|RL||RW |+ |SL|+ |SW |) + L + W ) (7)
and the memory complexity is
O(|RL|2|RW |
2 + L + W ). (8)
3.3 Improving the lower bound and problem preprocessing
In order to improve the computational performance of the Recursive Partitioning Approach,we start computing better lower bounds (feasible solutions) than the ones provided by the ho-mogeneous solutions (5). The idea is to generate cutting patterns simpler than generic uncon-strained non-guillotine cutting patterns, however, more elaborated than homogeneous patterns.
11
In this way, before performing phase 1 of Section 3.1, the approach computes optimal un-constrained two-staged guillotine cutting patterns for the plate (L, W ) and for a number ofsubrectangles of (L, W ). This computation uses the exact procedure in [26], based on a solutionof O(m) one-dimensional knapsack problems. Then, the approach computes optimal non-stagedguillotine cutting patterns for the plate (L, W ) and a number of subrectangles of (L, W ), usingthe value of the two-staged solutions as initial lower bounds. This computation employs theRecursive Five-block Algorithm specialized for the guillotine case (i.e., considering only verti-cal and horizontal guillotine cuts). These optimal guillotine solutions are used to reduce thetree search of the Recursive Five-block Heuristic in phase 1. Finally, the optimal first-ordernon-guillotine solutions found in phase 1 for the plate (L, W ) and a number of subrectangles of(L, W ) are used to reduce the dynamic programming recursions of the L-approach in phase 2(Section 3.2). We note that each phase of the approach is executed only if the solution given bythe previous phase cannot be proven to be optimal. Solutions found for the subproblems in agiven phase are used as lower bounds for the same subproblems in the next phase. In this way,solutions found in higher phases are at least as good as the ones found in earlier phases.
Using the same reasoning as in [9] for the manufacturer’s pallet loading, it can be shown thatthe worst-case time complexity of computing optimal unconstrained two-staged guillotine cuttingpatterns is O(m2(|SL|+ |SW |)+L+W ) and the memory complexity is O(m(|SL|+ |SW |)+L+W ). The worst-case time and memory complexities of computing optimal non-staged guillotinecutting patterns are O(|RL||RW |(|SL|+ |SW |)+L+W ) and O(|RL||RW |+L+W ), respectively.Summing up the worst-case time and space complexities of phases 1 and 2 and the ones ofimproving the lower bounds, we have that the worst-case time and memory complexities of theRecursive Partitioning Approach are given by O(|RL|
3|RW |3+(|RL|
2|RW |2 +m2)(|SL|+ |SW |)+
L + W ) and O(|RL|2|RW |
2 + m(|SL|+ |SW |) + L + W ), respectively.A final remark in this section is that as a preprocessing of the input of the Recursive Parti-
tioning Algorithm, our implementation of the algorithm may discard pieces that are not requiredto be in an optimal solution. Note that any piece type i that satisfies li ≥ lj , wi ≥ wj , andvi ≤ vj , for some piece type j 6= i, does not need to be considered, since j is at least as valuableas i and it is not larger than i. If this is the case, we say that piece type j dominates piecetype i. It is worth mentioning that this procedure may be useful for weighted instances only.This process could be generalized to the case where not only one, but a combination of piecesdominates another piece. That is, when there is a subset of pieces P and a piece i /∈ P , suchthat we can pack all pieces that belong to P (maybe using more than one of the same type) inrectangle i, and the packing has value greater than or equal to vi. For unweighted instances, if apiece i is dominated by pieces in set P , then there is a packing of the pieces in P in the rectanglei so that rectangle i is completely covered (i.e, a zero waste packing). Hence, all integer coniccombinations produced by piece i are also produced by the ones in the set P and, therefore,the exclusion of piece i does not contribute to a reduction on the number of patterns that thealgorithm must inspect. As the generalized process described above is a computational expen-sive task, in the present work we implemented a preprocessing procedure that considers theelimination of a piece dominated by another piece, whose worst-case time complexity is O(m2).
12
3.4 Heuristics for large problems
The generation of all patterns by the Recursive Partitioning Approach may be prohibitivefor large instances. Moreover, the amount of memory required by these algorithms may notbe available. For this reason, we propose heuristics that reduce both the time and memoryrequirements of the algorithms. These procedures, however, may lead to a loss of quality ofthe solution found. Since the time and memory complexities of generating all possible cuttingshighly depends on the sizes of the integer conic combinations and raster points sets (as pointedout in (7) and (8), respectively), we can significantly reduce time and memory requirements intwo ways: (i) by limiting the search depth of the recursions (i.e., setting parameter N 6= ∞ inAlgorithms 1–4); and (ii) by replacing the integer conic combinations and raster points sets bysmaller sets.
In order to reduce the sets of conic combinations SL and SW , it was suggested in [6] a simpleiterative procedure that starts eliminating the piece with the smallest length (width) until thedesired sizes of the sets are achieved. In this work we decided by an alternative procedure thatreplaces the sets SL and SW by the shrunk sets SL and SW , so that the product |SL||SW | islimited by a given threshold parameter M . Moreover, to substitute the raster points sets, theshrunk sets RL and RW are obtained by using definition (4) with SL and SW instead of SL andSW .
Algorithms 5–7 describe the implemented reduction strategy. Basically, the strategy consistsin selecting equally distributed elements within ordered versions of sets SL and SW . Algorithm 7describes the main routine named ReduceSets that uses Algorithms 5 and 6 as subroutines.Specifically, the heuristic version of the Recursive Partitioning Algorithm makes use of routineReduceSets in line 7 of Algorithm 1 to compute RL and RW based on SL and SW . Similarly,Algorithm 3 uses routine ReduceSets in line 2 to build sets SL and SW and call subroutineSolve-L (Algorithm 4) in line 3 with them, instead of SL and SW .
Algorithm 5: Select n numbers between s and e.Input: The number n of elements to be selected, the first element s to be considered and the last element
e to be considered. We suppose that s ≤ e and n ≤ e− s + 1.Output: A subset of {s, . . . , e} with n elements.Select(n, s, e)begin1
I ← ∅2
if n > 0 then3
I ← ⌊ s+e
2⌋4
if n > 1 then5
I ← I ∪ Select(⌊n−12⌋, s, ⌊ s+e
2⌋ − 1)6
I ← I ∪ Select(⌈n−12⌉, ⌊ s+e
2⌋+ 1, e)7
return I8
end9
13
Algorithm 6: Select n elements of S equally distributed. We suppose that n ≤ |S|. Si
denotes the i-th smallest element of S.Input: S and the number n of elements in the reduced set.Output: A subset of S with size n.ReduceSet(S, n)begin1
S ← ∅2
I ← Select(n, 1, |S|)3
foreach i ∈ I do4
S ← S ∪ {Si}5
return S6
end7
Algorithm 7: Given sets S and T , and a positive integer n, it creates sets S ⊆ S andT ⊆ T such that |S||T | ≈M if M < |S||T |. Otherwise, it returns S and T .
Input: Sets S and T and an integer M .Output: Sets S ⊆ S and T ⊆ T such that |S||T | ≈M .ReduceSets(S, T, M)begin1
p← |S||T |2
if p ≤M then3
return S and T4
s←lq
M
p|S|
m
5
t←lq
M
p|T |
m
6
S ← ReduceSet(S, s)7
T ← ReduceSet(T, t)8
S ← S ∪ {S1, S|S|}9
T ← T ∪ {T1, T|T |}10
return S and T11
end12
4 Numerical experiments
We implemented the Recursive Partitioning Approach and its heuristic counterpart for theunconstrained two-dimensional non-guillotine cutting problem as described in Algorithms 1–7.The algorithms were coded in C/C++ language. The experiments were performed in a 2.4GHzIntel Core 2 Quad Q6600 with 8.0GB of RAM memory and Linux Operating System. Compileroption -O3 has been adopted. The computer implementation of the algorithms as well as thedata sets used in our experiments and the solutions found are publicly available for benchmarkingpurposes at [49].
In the numerical experiments, we considered 95 problem instances found in the literature: H,HZ1 and HZ2 from [29], [32] and [33], respectively; GCUT1–GCUT13 and GCUT14–GCUT17from [5] and [18], respectively; M1–M5 and MW1–MW4 from [39] and [31], respectively; U1–U3and W1–W3 from [30]; U4, W4, LU1–LU4, LW1–LW4 from [31]; UU1–UU11 and UW1–UW11from [23]; APT10–APT29 from [1]; and B1–B7 from [19]. Table 1 presents some characteristics
14
of these instances. In the table, m is the original number of piece types while mr is the reducednumber of piece types obtained by applying the preprocessing procedure described in Subsec-tion 3.3, L and W are the length and width of the stock plate, and |SL|, |SW |, |RL| and |RW |are the number of elements of the sets of conic combinations and raster points, respectively,after applying the preprocessing procedure for the elimination of dominated pieces described inSubsection 3.3. It should be noted in Table 1 that the number of piece types of the instancesvaries from 5 to 200 and the number of conic combinations (or raster points) from a few tens tothousands. Therefore, the number of variables and constraints of model (1–3) for these instancesvaries from a few hundreds to billions.
We arbitrarily divided the experiments with these instances into two parts: the first consistsof experiments with instances of moderate size, defined as max{|SL|, |SW |} < 1, 000, and thesecond part contains experiments with the remaining large-sized instances.
Table 1: Characteristics of the instances (cont.).
4.1 Instances of moderate size
In this set of experiments, we imposed no limit to the search depth, i.e., we set N = ∞.Table 2 presents the values of the unconstrained two-stage, guillotine, first-order non-guillotine(Five-block Algorithm) and (superior-order) non-guillotine (L-algorithm) cutting patterns ob-tained by the Recursive Partitioning Approach for the instances of moderate size. The two-stage and guillotine solutions are computed before phase 1 to obtain non-trivial lower boundsas described in Section 3.3. The Five-block Algorithm solution and the L-Algorithm solutioncorrespond to phases 1 and 2 of the Recursive Partitioning Approach, respectively. The symbol“–” in the table means that an optimality certificate was found by closing the gap between theupper and the lower bound of the problem and, in consequence, the execution of the methodwas terminated. Columns with times represent the CPU time of each phase of the method.The time in the last column is the sum of the times of each phase plus the time used to readand preprocess the input data, compute lower and upper bounds for each possible subrectangle,draw and save the solution.
In the table, the numbers in bold indicate that the corresponding phase of the method
16
InstanceTwo-stage cuts Guillotine cuts Five-block Algorithm L-Algorithm Total
Solution Time (sec) Solution Time (sec) Solution Time (sec) Solution Time (sec) time
Table 2: Results obtained by the Recursive Partitioning Algorithm for instances of moderatesize.
improved the solution given by the previous phase. For example, note that for instances M1and UU8, the optimal guillotine pattern value coincides with the optimal two-stage patternvalue, while the optimal five-block pattern is better and the L-Algorithm pattern is even better.Figures 3 and 4 depict the corresponding optimal cutting patterns for instances M1 and UU8,respectively.
As expected, the optimal unconstrained two-stage and guillotine pattern values coincidewith the ones reported in the literature [29, 5, 39, 32, 33, 30, 23, 31, 1, 20, 18]. Moreover, theunconstrained non-guillotine solutions found by the Five-block Algorithm and the L-Algorithmimprove the guillotine ones in many instances. To the best of our knowledge, there are nostudies in the literature reporting unconstrained non-guillotine solutions for these instances. Aninteresting result in Table 2 is that most of the best solutions of the Recursive PartitioningApproach were found by the Five-block Algorithm, requiring affordable runtimes (only a fewseconds).
For instances H and HZ1, the Recursive Partitioning Approach gives an optimality certificate.
17
49× 4549× 45
49× 4549× 45
47× 6647× 66
31× 51
31× 51
31× 51
21× 87
47× 66
27× 32
27× 3221× 87 21× 87
16× 50
21× 87
21× 87 21× 87
27× 32
27× 32
47× 66
16× 50
31× 51
31× 51
(a) (b) (c)
Figure 3: Graphical representations of solutions found by the Recursive Partitioning Algorithmfor instance M1. (a) Optimal guillotine pattern with value 15,024. (b) First-order guillotinepattern with value 15,054. (c) L-Algorithm pattern with value 15,073.
770× 877 1228× 883
529× 555 729× 553 729× 553
529× 555 729× 553 729× 553
607× 753
607× 753
453× 492
453× 492
453× 492
936× 893
460× 592 460× 592
453× 492 453× 492 1091× 514
453× 492 1091× 514453× 492
563× 862
729× 553
720× 466
720× 466596× 650
704× 836
683× 628
(a) (b) (c)
Figure 4: Graphical representations of solutions found by the Recursive Partitioning Algorithmfor instance UU8. (a) Optimal guillotine pattern with value 3,959,352. (b) First-order guillotinepattern with value 3,969,784. (c) L-Algorithm pattern with value 3,970,877.
For instances HZ2, GCUT1–GCUT3, GCUT5–GCUT7, GCUT9, GCUT10, M1–M5 and MW1–MW5, an optimality certificate was obtained solving the LP-relaxation of model (1–3) using themodelling language GAMS 19.8 with the solver CPLEX 7. For all the remaining moderate-sizedinstances, we were unable to prove the optimality because the CPLEX execution was abortedwith a computer memory overflow error.
We also performed additional experiments with other 22 problem instances of the litera-ture [34, 36], for which the optimal solutions are known by construction. These unweigthedinstances were generated in such a way that there exists at least one optimal cutting pattern
18
with zero waste, that is, the value of this cutting pattern coincides with the area of the stockplate. For all instances C1P1–C4P3 in [34] and LCT1–LCT10 in [36], the Recursive PartitioningApproach was able to find an optimal solution. In all cases the optimal pattern is two-stageguillotine, with the exception of instance LCT3 for which the optimal pattern was obtained bythe Five-block Algorithm.
4.2 Large instances
In a first set of experiments with the large instances, we applied a heuristic version of theRecursive Partitioning Approach, without imposing limits to the search depth (i.e., settingN = ∞). Sets SL and SW were replaced in the guillotine, the five-block and the L-Algorithmphases by sets SL and SW generated by Algorithm 7 with the product threshold parameterM = 40, 000, 000, M = 150, 000 and M = 10, 000, respectively. Therefore, the best guillotine,five-block and non-guillotine solutions obtained by these algorithms may not be optimal.
Table 3 presents the values of the unconstrained two-stage, guillotine, first-order non-gui-llotine (Five-block Algorithm) and superior-order non-guillotine (L-algorithm) cutting patternsobtained by the heuristic version of the Recursive Partitioning Approach for the large-sizedinstances. We first note that the two-staged phase of this heuristic version is identical to theone of the exact version of the method, i.e., all two-staged solutions are optimal. Moreover,looking at the quantity |SL| × |SW | of each instance on Table 1, and considering that guillotinecuts of instances with |SL| × |SW | ≤ 40, 000, 000 are being solved to optimality, we know that,with the exception of instances LU1–LU4 and LW1–LW4, the guillotine cuts of all the large-sized instances are optimal too. Among the optimal guillotine cuts generated by our method,we were able to verify that, for instances GCUT13–GCUT17, U1–U3, W1, W3, UU9–UU11,and APT10–APT29, solutions found by our method are in agreement with previously publishedsolutions [30, 23, 31, 1, 19, 20, 18]. For the remaining instances there are no optimal guillotinesolutions reported in the literature. Even without this double checking, guillotine solutions forinstances U4, W4 and B1–B7 are optimal, but whether or not guillotine solutions for instancesLU1–LU4 and LW1–LW4 are optimal remains to be verified. A remark for instances U2 and U3is in order. Instances U2 and U3 were introduced in [30]. [20] reports their optimal guillotinepattern values as being 20,232,224 and 48,142,840, respectively, mentioning that these optimalvalues can be obtained by running the algorithm for staged patterns presented in [19] (setting themaximum allowed number of stages to infinity). These values are slightly larger than the onesreported in Table 3, that should be optimal. We implemented and run the method introducedin [19], and the same values reported in Table 3 were found, which suggests that the optimalvalues for instances U2 and U3 reported in [20] may be incorrect. To reinforce this idea, we notethat, as far as we know, there is no publication introducing a method (exact or heuristic) thatfinds better quality solutions than the ones being reported here, while some publications reportequal or lower quality solutions [30, 1, 20].
Regarding Table 3, it is worth remarking that instances LU1–LU4, LW1–LW4 are hugeinstances and involve tens of thousands of conic combinations. Note that the guillotine solutionfound for instance B7 is proven to be optimal. Note also that most of the best solutions wereobtained by applying only guillotine cuts, but the demanded runtimes are generally much higherthan the ones in the moderate-sized instances of Table 2. Exceptions are instances GCUT13,
19
W3, W4, UU9 and LU4 for which none of the possible guillotine partitions (neither horizontalnor vertical) provides a lower bound greater than the value of the optimal two-stage pattern.Other exceptions are instances APT21 and APT22 for which the Five-block Algorithm was ableto improve the lower bound given by the guillotine partitions. On the other hand, note thatthe optimal two-stage solutions in the table are reasonably good, if compared to the guillotinesolutions, and they are obtained in just a couple of seconds.
InstanceTwo-stage cuts Guillotine cuts Five-block Algorithm L-Algorithm Total
Solution Time (sec) Solution Time (sec) Solution Time (sec) Solution Time (sec) time
Table 3: Results obtained by a heuristic version of the Recursive Partitioning Algorithm for thelarge instances. The sets of conic combinations were limited in the guillotine, five-block andL-Algorithm phases of the method.
In a second set of experiments, we applied another heuristic version of the Recursive Parti-tioning Approach, using the complete conic combinations sets in all the phases of the method,fixing the search depth limit parameter N = ∞ in the guillotine phase and N = 1 in the five-block phase, and skipping the L-Algorithm phase of the method. Table 4 presents the values
20
of the unconstrained two-stage, guillotine and first-order non-guillotine (Five-block Algorithm)cuts obtained by this heuristic version of the Recursive Partitioning Approach for some of thelarge-sized instances. The unconstrained two-stage and guillotine pattern values coincide withthe ones of Table 3. Note, however, that the Five-block Algorithm was able to find improvednon-guillotine solutions for most of these examples (if compared to Table 3), at the expensesof much higher running times. In particular, since the upper bound on the optimal value forinstance GCUT14–GCUT17 provided by the algorithm is 12,250,000, we note that the five-blocksolution found for instance GCUT17 is proven to be optimal. Besides that, note that, for in-stance APT22, the heuristic version of the Five-block Algorithm with N = 1 and using thecomplete set of conic combinations found a better solution than the previous heuristic versionwith N =∞ and a shrunk set of conic combinations (see Table 3).
InstanceTwo-stage Guillotine cuts Five-block Total
Solution Time (sec) Solution Time (sec) Solution Time (sec) time
Table 4: Results obtained by a heuristic version of the Recursive Partitioning Approach forinstances GCUT14–GCUT17 and APT10–APT29. The search depth limit was set to N = 1 inthe five-block phase and the complete conic combinations sets were used in all the phases of themethod.
In addition to the experiments described above, we arbitrarily decided to solve the two largeinstances UU9 and UU10 with the non-heuristic version of the Recursive Partitioning Approach.While for instance UU9 the best solution obtained corresponds to a two-stage pattern with value6,100,692, for instance UU10, each phase of the method improved the solution found by theprevious phase. Figure 5 illustrates the corresponding cutting patterns obtained by each phasefor instance UU10. The total runtimes for solving instances UU9 and UU10 were 4,321.59 and8,908.24 seconds, respectively.
A final remark on the preprocessing scheme of the input of the Recursive Partitioning Al-gorithm is in order. The preprocessing scheme for eliminating dominated items, described inthe last paragraph of Subsection 3.3, applies to weighted instances only (35 over a total of 95).Table 1 showed the number m of original items and the number mr of remaining items afterapplying the preprocessing scheme to each instance. A reduction in the number of items may
21
1387× 7302037× 731
865× 839865× 839865× 839865× 839
1420× 9352076× 932
1420× 9352076× 932
1387× 730
1420× 935
1420× 935
891× 1664
1181× 833
1181× 833
2076× 932
865× 839 865× 839 865× 839 865× 839
(a) (b)
1444× 1492
2037× 731
1484× 1957
1003× 1129 1003× 1129
2002× 795
2002× 795
712× 1618
1387× 7301387× 730
1207× 786
780× 796
1206× 1128
2002× 795
1420× 935865× 839
1136× 990 1136× 990
(c) (d)
Figure 5: Graphical representations of solutions found by the Recursive Partitioning Algorithmfor instance UU10. (a) Optimal two-stage pattern with value 11,929,561. (b) Optimal guillotinepattern with value 11,955,852. (c) First-order guillotine pattern with value 11,995,637. (d)L-Algorithm pattern with value 12,001,291.
imply in a reduction on the size of the conic combinations and raster points sets. Consideringthe 35 weighted instances, the average reduction in the product |SL||SW | was 42.80% while theaverage reduction in the product |RL||RW | was 46.02%. Extreme cases were instances HZ2 andMW1, for which there was no reduction at all, and instances UW5 and W3. Instance UW5 hada reduction of 97.60% in the product |SL||SW |, while instance W3 had a reduction of 99.16% inthe product |RL||RW |. We illustrate the running time reduction in instances UW6, UW8 andUW9, for which the reductions in |SL||SW | and |RL||RW | were, 78.67% and 84.57%, 82.76%and 90.66%, and 90.13% and 78.21%, respectively. The running time for solving instance UW6without preprocessing was 1,837.47 seconds, while this time went down to 16.77 seconds whenusing the preprocessing strategy. For instances UW8 and UW9, the running times without pre-processing were 10,639.46 and 802.19 seconds, respectively, and, 28.92 and 16.02 seconds withpreprocessing, respectively.
22
5 Concluding remarks
While a large number of studies in the literature have considered staged and non-stagedtwo-dimensional guillotine cutting problems, much less studies have considered two-dimensionalnon-guillotine cutting problems (constrained and unconstrained), and only a few of them haveproposed exact methods to generate non-guillotine patterns. Moreover, most of the approaches(exact and heuristic) for non-guillotine cutting (or packing) were developed for the constrainedproblem, which can be more interesting for certain practical applications with relatively lowdemands of the ordered items. However, part of these methods may not perform well whensolving the unconstrained problem. On the other hand, the unconstrained problem is particularlyinteresting for cutting stock applications with large-scale production and weakly heterogeneousitems, in which the problem plays the role of a column generation procedure.
This study presented a Recursive Partitioning Approach to generate unconstrained two-dimensional non-guillotine cutting (or packing) patterns. The approach was able to find theoptimal solution of a large number of moderate-sized instances known in the literature and wewere unable to find a counterexample for which the approach fails to find a known optimalsolution. To cope with large instances, we combined the approach with simple heuristics toreduce its computational efforts. For moderate-sized instances, both the five-block and the L-Algorithm phases of the approach seem to be promising alternatives for obtaining reasonablygood or optimal non-guillotine solutions under affordable computer runtimes, whereas for largerinstances, the guillotine or the five-block phase may be preferable, depending on the definition ofan acceptable time limit. An interesting perspective for future research is to extend the RecursivePartitioning Approach to deal with constrained two-dimensional non-guillotine cutting.
References
[1] R. Alvarez-Valdes, A. Parajon, and J. M. Tamarit. A tabu search algorithm for large-scaleguillotine (un)constrained two-dimensional cutting problems. Computers and OperationsResearch, 29:925–947, 2002.
[2] R. Alvarez-Valdes, F. Parreno, and J. M. Tamarit. A tabu search algorithm for a two-dimensional non-guillotine cutting problem. European Journal of Operational Research,183:1167–1182, 2007.
[3] M. Arenales and R. Morabito. An and/or-graph approach to the solution of two-dimensionalnon-guillotine cutting problems. European Journal of Operational Research, 84:599–617,1995.
[4] R. Baldacci and M. A. Boschetti. A cutting-plane approach for the two-dimensional orthog-onal non-guillotine cutting problem. European Journal of Operational Research, 183:1136–1149, 2007.
[5] J. E. Beasley. Algorithms for unconstrained two-dimensional guillotine cutting. Journal ofthe Operational Research Society, 36:297–306, 1985.
23
[6] J. E. Beasley. An exact two-dimensional non-guillotine cutting tree-search procedure. Op-erations Research, 33:49–64, 1985.
[7] J. E. Beasley. A population heuristic for constrained two-dimensional non-guillotine cutting.European Journal of Operational Research, 156:601–627, 2004.
[8] E. G. Birgin and R. D. Lobato. Orthogonal packing of identical rectangles within isotropicconvex regions. Computers & Industrial Engineering. DOI: 10.1016/j.cie.2010.07.004.
[9] E. G. Birgin, R. D. Lobato, and R. Morabito. An effective recursive partitioning approachfor the packing of identical rectangles in a rectangle. Journal of the Operational ResearchSociety, 61:306–320, 2010.
[10] E. G. Birgin, J. M. Martınez, W. F. Mascarenhas, and D. P. Ronconi. Method of sentinelsfor packing items within arbitrary convex regions. Journal of the Operational ResearchSociety, 57:735–746, 2006.
[11] E. G. Birgin, J. M. Martınez, F. H. Nishihara, and D. P. Ronconi. Orthogonal packing ofrectangular items within arbitrary convex regions by nonlinear optimization. Computersand Operations Research, 33:3535–3548, 2006.
[12] E. G. Birgin, R. Morabito, and F. H. Nishihara. A note on an L-approach for solvingthe manufacturer’s pallet loading problem. Journal of the Operational Research Society,56:1448–1451, 2005.
[13] A. Bortfeldt and T. Winter. A genetic algorithm for the two-dimensional knapsack problemwith rectangular pieces. International Transactions in Operational Research, 16:685–713,2009.
[14] M. A. Boschetti, A. Mingozzi, and E. Hadjiconstantinou. New upper bounds for the two-dimensional orthogonal non-guillotine cutting stock problem. IMA Journal of ManagementMathematics, 13:95–119, 2002.
[15] A. Caprara and M. Monaci. On the two-dimensional knapsack problem. Operations Re-search Letters, 32:5–14, 2004.
[16] C. S. Chen, S. M. Lee, and Q. S. Shen. An analytical model for the container loadingproblem. European Journal of Operational Research, 80:68–76, 1995.
[17] D. Chen and W. Huang. A new heuristic algorithm for constrained rectangle-packingproblem. Asia-Pacific Journal of Operational Research, 24:463–478, 2007.
[18] 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 andcolumn generation. European Journal of Operational Research, 191:61–85, 2008.
[19] Y. Cui, Z. Wang, and J. Li. Exact and heuristic algorithms for staged cutting problems.Proceedings of the Institution of Mechanical Engineers, Part B: Journal of EngineeringManufacture, 219:201–207, 2005.
24
[20] Y. Cui and X. Zhang. Two-stage general block patterns for the two-dimensional cuttingproblem. Computers and Operations Research, 34:2882–2893, 2007.
[21] H. Dyckhoff. A typology of cutting and packing problems. European Journal of OperationalResearch, 44:145–159, 1990.
[22] J. Egeblad and D. Pisinger. Heuristic approaches for the two- and three-dimensional knap-sack packing problem. Computers and Operations Research, 36:1026–1049, 2009.
[23] D. Fayard, M. Hifi, and V. Zissimopoulos. An efficient approach for large-scale two-dimensional guillotine cutting stock problems. Journal of the Operational Research Society,49:1270–1277, 1998.
[24] S. P. Fekete, J. Schepers, and J. C. van der Veen. An exact algorithm for higher-dimensionalorthogonal packing. Operations Research, 55:569–587, 2007.
[25] Y.-G. G and M.-K. Kang. A new upper bound for unconstrained two-dimensional cuttingand packing. Journal of the Operational Research Society, 53:587–591, 2002.
[26] P. C. Gilmore and R. E. Gomory. Multistage cutting stock problems of two and moredimensions. Operations Research, 13:94–120, 1965.
[27] J. F. Goncalves. A hybrid genetic algorithm-heuristic for a two-dimensional orthogonalpacking problem. European Journal of Operational Research, 183:1212–1229, 2007.
[28] E. Hadjiconstantinou and N. Christofides. An exact algorithm for general, orthogonal,2-dimensional knapsack-problems. European Journal of Operational Research, 83:39–56,1995.
[29] J. C. Herz. Recursive computational procedure for two-dimensional stock cutting. IBMJournal of Research and Development, 16:462–469, 1972.
[30] M. Hifi. The DH/KD algorithm: a hybrid approach for unconstrained two-dimensionalcutting problems. European Journal of Operational Research, 97:41–52, 1997.
[31] M. Hifi. Exact algorithms for large-scale unconstrained two and three staged cutting prob-lems. Computational Optimization and Applications, 18:63–88, 2001.
[32] M. Hifi and V. Zissimopoulos. A recursive exact algorithm for weighted two-dimensionalcutting. European Journal of Operational Research, 91:553–564, 1996.
[33] M. Hifi and V. Zissimopoulos. Une amelioration de l’algorithme recursif de Herz pour leprobleme de decoupe a deux dimensions. RAIRO, 30:111–125, 1996.
[34] E. Hopper and B. C. H. Turton. An empirical investigation of meta-heuristic and heuristicalgorithms for a 2D packing problem. European Journal of Operational Research, 128:34–57,2001.
[35] W. Huang and D. Chen. An efficient heuristic algorithm for rectangle-packing problem.Simulation Modelling Practice and Theory, 15:1356–1365, 2007.
25
[36] T. W. Leung, C. K. Chan, and M. D. Troutt. Application of a mixed simulated annealing-genetic algorithm heuristic for the two-dimensional orthogonal packing problem. EuropeanJournal of Operational Research, 145:530–542, 2003.
[37] L. Lins, S. Lins, and R. Morabito. An L-approach for packing (l, w)-rectangles into rect-angular and L-shaped pieces. Journal of the Operational Research Society, 54:777–789,2003.
[38] W. F. Mascarenhas and E. G. Birgin. Using sentinels to detect intersections of convex andnonconvex polygons. Computational & Applied Mathematics, 29:247–267, 2010.
[39] R. Morabito, M. Arenales, and V. F. Arcaro. An and-or-graph approach for two-dimensionalcutting problems. European Journal of Operational Research, 58:263–271, 1992.
[40] R. Morabito and S. Morales. A simple and effective recursive procedure for the manufac-turer’s pallet loading problem. Journal of the Operational Research Society, 49:819–828,1998.
[41] R. Morabito and S. Morales. Erratum to ’A simple and effective recursive procedure forthe manufacturer’s pallet loading problem’. Journal of the Operational Research Society,50:876–876, 1999.
[42] M. Padberg. Packing small boxes into a big box. Mathematical Methods of OperationsResearch, 52:1–21, 2000.
[43] G. Scheithauer. LP-based bounds for the container and multi-container loading problem.International Transactions in Operational Research, 6:199–213, 1999.
[44] G. Scheithauer and J. Terno. Modeling of packing problems. Optimization, 28:63–84, 1993.
[45] G. Scheithauer and J. Terno. The G4-heuristic for the pallet loading problem. Journal ofthe Operational Research Society, 47:511–522, 1996.
[46] R. D. Tsai, E.E. Malstrom, and W. Kuo. 3-dimensional palletization of mixed box sizes.IIE Transactions, 25:64–75, 1993.
[47] G. Waescher, H. Haußner, and H. Schumann. An improved typology of cutting and packingproblems. European Journal of Operational Research, 183:1109–1130, 2007.
[48] L. Wei, D. Zhang, and Q. Chen. A least wasted first heuristic algorithm for the rectangularpacking problem. Computers and Operations Research, 36:1608–1614, 2009.