This article was originally published in a journal published by

Elsevier, and the attached copy is provided by Elsevier for the

author’s benefit and for the benefit of the author’s institution, for
non-commercial research and educational use including without
limitation use in instruction at your institution, sending it to specific
colleagues that you know, and providing a copy to your institution’s
administrator.
All other uses, reproduction and distribution, including without
limitation commercial reprints, selling or licensing copies or access,
or posting on open internet sites, your personal or institution’s
website or repository, are prohibited. For exceptions, permission
may be sought for such use through Elsevier’s permissions site at:

http://www.elsevier.com/locate/permissionusematerial
 European Journal of Operational Research 183 (2007) 1405–1420
www.elsevier.com/locate/ejor

Optimising the cutting of wood fibre plates in the

py
hardboard industry

co
Reinaldo Morabito *, Luciano Belluzzo
Production Engineering Department, Universidade Federal de São Carlos, 13565-905 São Carlos, SP, Brazil

Received 10 September 2004; accepted 22 November 2005

Available online 12 June 2006

al
Abstract
on
Hardboard companies transform eucalyptus trunks into rectangular wood fibre plates basically by means of processes
of disintegration and reconstitution of wood fibres. Such plates called hardboards are then cut into ordered items (smaller
rectangles) to satisfy customer demands. In this paper, we present approaches to generate cutting patterns that minimize
the cost or waste of material, considering different particular constraints associated with longitudinal and transversal saws,
rs

head cuts, book rotation and item unloading stations of the cutting machine. The methods are based on dynamic program-
ming recursive formulas combined with greedy constructive heuristics and the primal simplex algorithm. To illustrate the
application of these approaches, a case study was carried out in a Brazilian hardboard company. The results show that the
pe

approaches are able to produce better solutions than the ones currently used by the company.
Ó 2006 Elsevier B.V. All rights reserved.

Keywords: Cutting; Packing; Dynamic programming; Hardboard industry

r's

1. Introduction

In this paper we study the problem of cutting rectangular wood fibre plates into ordered items (smaller rect-
angles) to satisfy demands in the hardboard industry (these demands are typically large quantities ordered by
o

furniture and automobile companies). The decisions made in the cutting process are important for the produc-
tion planning of the plant due to the costs of the material waste (trim loss) and the effects in equipment pro-
th

ductivity. Such waste consists of good-quality hardboard scraps, which are useless for practical purposes
because of their small sizes. Part of this waste can be avoided by a more effective production planning of
the cutting machine, which does not necessarily imply additional investments. The aim of the cutting stock
Au

problem is to find a way to produce the ordered items from the objects (hardboards) such that a criterion
is optimised, for example, minimizing the cost of the objects or the amount of waste.
Cutting and packing problems have been extensively treated in the literature in the last decades. For surveys
and special issues, the reader may consult Dyckhoff (1990), Dowsland and Dowsland (1992), Sweeney and

*
Corresponding author. Tel.: +55 16 33518237x216; fax: +55 16 33518240.
E-mail address: morabito@power.ufscar.br (R. Morabito).

0377-2217/$ - see front matter Ó 2006 Elsevier B.V. All rights reserved.
doi:10.1016/j.ejor.2005.11.066
1406 R. Morabito, L. Belluzzo / European Journal of Operational Research 183 (2007) 1405–1420

Paternoster (1992), Dyckhoff and Finke (1992), Martello (1994), Bischoff and Waescher (1995), Dyckhoff et al.
(1997), Arenales et al. (1999), Wang and Waescher (2002), Hifi (2002), Lodi et al. (2002) and ESICUP (2005)
(EURO Special Interest Group on Cutting and Packing). Due to the diversity of practical cases and the com-
plexity of exact algorithms (the problems are generally NP-hard), most approaches found in the literature are
heuristic. According to Waescher et al.’s (2006) typology, the present hardboard cutting problem can be cat-
egorized as an extended multiple stock size two-dimensional cutting stock problem, since it involves additional
relevant aspects such as the cutting pattern sequencing (as discussed in Section 2). The problem requires that a
weakly heterogeneous assortment of small items be completely allocated to a selection of large objects of min-

py
imal value (i.e., an input minimization type problem).
A case study was performed in a Brazilian hardboard company with a highly automated cutting process.
Due to the constraints imposed by the cutting equipment, the cuts are of a guillotine type with at most three
particular stages, there are limitations in the dimensions of hardboards and the longitudinal and transversal

co
cuts, besides other less usual considerations such as head cuts, rotation of the book (pack of plates) and num-
ber of item unloading stations. To solve this particular cutting stock problem, we present approaches based on
dynamic programming techniques integrated in greedy constructive heuristics and the primal simplex algo-
rithm, similar to Morabito and Garcia (1998). It is worth mentioning that due to the unusual constraints
of the cutting machine, the classical cutting models known in the literature do not represent the present prob-
lem satisfactorily. Moreover, we are not aware of other studies dealing with this particular case, or treating

al
other related cases that could be directly applied here. The studies in Yanasse et al. (1991) and Morabito
and Garcia (1998) also deal with problems of cutting wood plates and hardboards, however, involving differ-
ent machines with characteristics and restraints distinct of the present equipment.
on
This paper is organized as follows: in the following section (Section 2), we discuss the production process of
hardboards focusing on the cutting process. In Section 3, we review the primal simplex algorithm with column
generation briefly and we present a refinement of a greedy constructive heuristic for two-dimensional cutting
rs

stock problems. Then we propose recursive formulas of dynamic programming to generate feasible cutting
patterns for these approaches. In Section 4, the computational performance of the methods is illustrated solv-
ing an actual example of the hardboard company and randomly generated examples. Finally, in Section 5 we
pe

present concluding remarks and perspectives for future research.

2. Cutting process

Hardboard companies transform eucalyptus trunks into rectangular wood fibre plates basically by means
of industrial processes of disintegration and reconstitution of wood fibres. First the trunks are washed,
chipped and stored in open areas to dry off and then, they are transformed to fibres by means of a thermo-
r's

mechanical process. The fibres are diluted in water yielding a pulp, which is then filtered and pressed to shape
as rectangular plates. After thermal treatment and humidification, these plates composed of reconstituted
wood fibres pressed together are known as hardboards. The hardboards are then cut into smaller rectangles
o

to satisfy the order list. For more details of the hardboard production process, readers are referred to Belluzzo
(2002).
th

Fig. 1 depicts an example of a hardboard cutting machine (Holzma saw) with a capacity of cutting 45 hard-
boards tons per hour. This machine is basically composed of plate loading stations, a set of circular saws
(which produce longitudinal and transversal cuts on the plates), transporters to move and spin the book of
Au

plates, and five item unloading stations (four automatic stations with pallet devices and one manual station).
This machine is able to cut a family of particular 3-stage guillotine patterns (defined below) because of the
book rotating systems. All its components, from the plate loading stations to the item unloading stations,
are controlled by the computer system in the control station, reducing to almost zero the set-up times of
changing cutting patterns.

2.1. Longitudinal and transversal cuts

Pieces of hardboard are produced in the company’s production lines with lengths less than 5600 millimetres
(mm) and widths less than 2200 mm. Their quantities available in stock are often sufficiently large (compared
 R. Morabito, L. Belluzzo / European Journal of Operational Research 183 (2007) 1405–1420 1407

py
co
al
Fig. 1. Scheme of the cutting machine.
on
to typical item demands) so that they can be considered unlimited for the purpose of the production planning
of the cutting machine. The circular saws are able to produce only orthogonal guillotine cuts on the plates (an
orthogonal guillotine cut is a cut that, when applied to a rectangle, produces two rectangles). The maximum
length of the longitudinal (horizontal) and transversal (vertical) cuts is 5600 and 2200 mm, respectively.
rs

2.2. Head cuts

pe

Head cuts are the vertical guillotine cuts that divide the plate into two parts: main and head (left and right
parts of the pattern – see Figs. 2 and 3). These cuts may reduce the waste of the cutting patterns; on the other
hand, they increase the processing times for cutting the patterns. A head may contain a strip with items of the
same length (e.g., heads 1, 2, 3 and 5 of Fig. 2), or various strips of identical items (a homogeneous solution
like head 4 of Fig. 2). The cutting machine can produce patterns with at most five head cuts (note that the
homogeneous solution is considered as only one head, in spite of having different strips). To make a head
r's

cut (by the longitudinal saw), the plate book should rotate by 90° in a clockwise direction. If there are no more
head cuts in the pattern, the main part should rotate by an additional 90° in order to complete a turn of 180°.
o

Heads
5a
4a 3a 2a 1º
th
Au

Head cut

Head with a simple strip Head with homogeneous sol.

Fig. 2. Pattern with multiple head cuts.
1408 R. Morabito, L. Belluzzo / European Journal of Operational Research 183 (2007) 1405–1420

x≥1000

py
y≤2200
Fig. 3. Limits for the lengths of the main part (left) and a single head (right).

co
After each head cut, the length of the main part of the pattern should be greater than or equal to 1000 mm.
Such a restraint is because of the system of holders that moves the plate book. In Fig. 3, x indicates the length
of the main part of the pattern and y, the length of the head part composed by a single head. Note that the
head length y should be less than or equal to 2200 mm; otherwise, the items of the head cannot be cut by the

al
transversal saw (as discussed above).

2.3. Book rotation

on
The cutting machine produces at most one book rotation (a complete turn of 180°). This rotation allows the
cutting of patterns with at most three stages (Fig. 4). In the first stage, parallel guillotine cuts are produced
along one of the dimensions of the plate (e.g., the head cut of Fig. 4a) and, in the next two stages, parallel
rs

guillotine cuts are produced along the opposite dimensions of the plate, respectively (e.g., the three horizontal
cuts and the three remaining vertical cuts of Fig. 4a, respectively), that is, the cuts of a stage are perpendicular
to the cuts of the predecessor stage. Note that, in order to cut 3-stage patterns, head cuts are needed. In this
pe

way, only a particular family of 3-stage guillotine patterns can be cut by the machine, as illustrated in Fig. 4.
Observe that the pattern of Fig. 4b is infeasible because its head part involves cuts in two stages, whereas the
pattern of Fig. 4c is infeasible because its main part involves cuts in three stages (two stages with trimming).
Without the book rotation, the machine can produce guillotine patterns with at most two stages.

2.4. Unloading stations

r's

The cutting machine has five item unloading stations, four automatic ones and one manual. A cutting pat-
tern requiring only automatic unloading stations is desirable, since the manual station needs operators, which
implies additional costs. Thus, the patterns should preferably have at most four items of different sizes, one for
o

each automatic unloading station; otherwise, the remaining item sizes have to be unloaded in the manual
station. Moreover, if the pallet devices of the automatic unloading stations are operating, they impose an
th
Au

(a) Feasible 3-stage (b) Infeasible 3-stage (c) Infeasible 3-stage

pattern pattern pattern
Fig. 4. Examples of feasible and infeasible 3-stage guillotine patterns for the machine.
 R. Morabito, L. Belluzzo / European Journal of Operational Research 183 (2007) 1405–1420 1409

Head cut

Main Head

py
Retrim Head cut

co
Fig. 5. Retrim.

additional restraint: while the pallet is not completed (being loaded with a certain item size), the station cannot
unload other item sizes. This implies that, given a cutting sequence of the patterns, the maximum number of
open stacks of items (along this sequence) is four, that is, one stack for each station. This additional restraint

al
can be relaxed if the pallet devices are not operating; in this case the patterns should preferably have at most
four item sizes. If the manual station is in use, these two constraints can be disregarded and the patterns may
have any number of item sizes.
on
2.5. Saw thickness and cuts for border correction and retrim
rs

When producing a cut, the circular saws remove 6 mm of material because of their thickness. To correct the
edges of the hardboards, the saws remove usually 20 mm along the plate length and 17 mm along the width
(including the saw thickness of 6 mm). The retrim is an internal cut usually of 20 mm to correct the main part
pe

of the pattern, after the last head cut (Fig. 5).

To summarize, the main constraints of the cutting process considered in this study are

(i) Longitudinal and transversal orthogonal guillotine cuts with limited lengths of 5600 and 2200 mm,
respectively.
(ii) Longitudinal and transversal saw thickness of 6 mm, border corrections of 20 and 17 mm, and retrim of
20 mm.
r's

(iii) Patterns with at most 5 head cuts: each head cut produces either a strip of items of the same length, or
different strips of identical items (homogeneous solution).
(iv) Patterns with main part length greater than or equal to 1000 mm, and a head length less than or equal to
o

2200 mm.
(v) Particular 3-stage guillotine patterns due to the restraint of head cuts and at most one book rotation.
th

(vi) If the manual unloading station is not in use and the pallet devices are not operating, the patterns must
contain at most 4 item sizes because of the limited number of automatic unloading stations.
(vii) If the manual unloading station is not in use and the pallet devices are operating, the maximum number
Au

of open stacks of items (along the sequence of cutting patterns) must be at most 4.

Note that constraint (vii) implies that constraint (vi) is satisfied, but the converse is not true. Note also that if
the manual station is in use, constraints (vi) and (vii) can be ignored. It is worth mentioning that we are not
aware of studies in the cutting and packing literature dealing with this particular set of constraints (i)–(vii).

3. Solution approaches

In the following approaches we consider all constraints (i)–(vii) discussed in Section 2, but constraints (vi)
and (vii) are considered with loss of generality, by means of simple heuristic procedures. It should be noted
1410 R. Morabito, L. Belluzzo / European Journal of Operational Research 183 (2007) 1405–1420

that constraint (vii) is related to an NP-hard problem of cutting pattern sequencing, called the maximum num-
ber of open stacks problem (Yuen, 1995; Yanasse, 1997; Becceneri et al., 2004). A more elaborate and effective
approach combining such problem with the hardboard cutting stock problem is beyond the scope of the pres-
ent paper and it is a topic for future research. As mentioned, these pattern sequencing decisions can be dis-
regarded if the manual unloading station is in use, or the pallet devices of the automated unloading
stations are not operating.

3.1. Problem modelling

py
As mentioned in Section 1, the present hardboard cutting problem is an extended multiple stock size cutting
stock problem. Let m be the number of items of different sizes, each size i, i = 1, . . . , m, with dimensions (li, wi),
where li and wi denote the item length and width, respectively. Let bi be Pthe ordered quantity of item size i. We

co
m
assume that the hardboard stock is sufficiently large to produce all i¼1 bi demanded items, as discussed in
Section 2. Consider initially that all hardboards are identical and all possible cutting patterns are known. Each
piece of hardboard has dimensions (L, W), where L and W denote its length and width, respectively. Without
loss of generality, by simply adding 6 mm to the dimensions li, wi, L and W, the saw thickness restraint is sat-
isfied (Gilmore and Gomory, 1965; Morabito and Arenales, 2000). Moreover, subtracting 20 and 17 mm from
the lengths and widths of the hardboards, respectively, we take into account the border correction cuts (see

al
constraint (ii) in Section 2).
For each cutting pattern, say the jth pattern, we associate the vector (a1j, a2j, . . . , amj), where each aij corre-
sponds to the number of Ptimes that item size i appears in pattern j. Let cj be the cost of pattern j (or the waste
on
of material cj ¼ LW  mi¼1 li wi aij ). The cutting stock problem is formulated as the following integer linear
program:
X
ðPÞ min cj xj ð1Þ
rs

j
X
s:t: aij xj P bi ; i ¼ 1; . . . ; m ð2Þ
pe

xj P 0; integer ð3Þ
where each variable xj corresponds to the number of times that pattern j is cut. In problems where the number
of possible patterns is very large (which are common in practice), problem (P) is generally hard to optimally
solve. Gilmore and Gomory (1961, 1963, 1965) suggested: (i) relax the integrality constraints (3) of problem
(P), (ii) solve the relaxed problem by the simplex method, starting from an initial base with m patterns and, in
r's

each simplex iteration, generating a new pattern to replace one of the m patterns in the current base. There-
fore, in each simplex iteration, the following subproblem should be solved:
Xm
ðP1Þ max pi aij
o

i¼1

subject to: vector ða1j ; a2j ; . . . ; amj Þ corresponds to a feasible pattern j

th

where pi is the dual variable associated to constraint P i of problem (P) for the current base. The procedure ter-
minates if the solution of subproblem (P1) satisfies mi¼1 pi aij 6 cj . If there are hardboards of different sizes,
Au

(P1) should be solved for each size. This procedure can be useful when the demand bi is sufficiently large com-
pared to each aij (as is the case of the present cutting problem), so that a simple rounding of the relaxed solu-
tion may result in a good solution for problem (P). The main difficulty of the procedure is to solve subproblem
(P1). According to Waescher et al. (2006)’s typology, this problem is a single large object placement problem,
since it requires that a single hardboard has to be packed with a selection (subset) from a given set of weakly
heterogeneous assortment of small items, such that the value of the packed items is maximized (i.e., an output
maximization type problem).
Some authors also suggested the use of greedy constructive heuristics as an alternative to solve problem (P).
Let vi be the value of item size i (e.g., its area liwi). An example is the repeated exhaustion reduction (Hinxman,
1980), basically stated as: While the order list is not produced do: (i) Generate the best cutting pattern, that is,
 R. Morabito, L. Belluzzo / European Journal of Operational Research 183 (2007) 1405–1420 1411

solve subproblem (P1) with pi = vi. (ii) Repeat this pattern as much as possible as a function of the item
demands (i.e., cut this pattern the maximum possible number of times taking into account the items in this
pattern and their current demand). (iii) Update the item demand, that is, remove the amount of items cut
in step 2 from the order list. Eventually add items of new orders to the order list.
As with the procedure of Gilmore and Gomory, the main difficulty of this heuristic is to solve subproblem
(P1). Some advantages is that it is easy to understand andP implement, it provides some flexibility to treat prob-
lems in which the demand must be satisfied exactly (i.e., j aij xj ¼ bi ; i ¼ 1; . . . ; m, instead of (2)), and it can
be useful in situations in which items of new orders are dynamically added to the current order list. However, a

py
drawback of this heuristic is that, despite generating patterns with low material waste in the first iterations, as
the procedure advances, patterns with high waste tend to be generated, deteriorating the global solution of the
problem.
An alternative to attenuate this shortcoming is by modifying the item values vi in such a way as to avoid less

co
favourable items in the last patterns. Let B = (a1, a2, . . . , ak), k 6 m, be the output of the heuristic above, where
each aj = (a1j, a2j, . . . , amj) corresponds
P to a cutting pattern of cost cj. The idea is to find item dual values pi that
minimize the deviation between mi¼1 pi aij and cj, similar to the simplex method in which B is a base and the
linear system pTB = cT has a unique solution producing the simplex multipliers p. It can be shown that,
because of the manner each pattern aj is generated in the heuristic, the rank of matrix B (as defined above)
is k. If k = m the system BTp = c has a unique solution. Otherwise (k < m), it is undetermined (infinite solu-

al
tions), which can be identified, for example, using the Gauss elimination method (one or more rows of the
matrix are null). In this case the free variables (null pivots) are simply fixed to zero.
For simplicity, consider that all hardboards are identical and the costs of all patterns are the same, say
on
cj = 1. The greedy constructive heuristic is refined as follows: (i) Start with item values vi = li wi (i.e., the item
areas) and dual values pi = 0. (ii) Update the item values with v0i ¼ ð1 þ pi Þvi and apply the three-step repeated
exhaustion reduction (defined above). (iii) If a limited number of iterations is reached (or the item values of
rs

two consecutive iterations are sufficiently close), stop with the best solution found so far; otherwise, update the
dual values pi solving the linear system BTp = c and go back to step (ii). Note that in the first iteration the
item values are equal to the areas, and in the next iterations these areas are ‘‘corrected’’ (increased or
pe

decreased) by pi.
In next section we propose recursive formulas of dynamic programming to solve subproblem (P1) for the
present hardboard cutting process.

3.2. Pattern generation

r's

Without loss of generality, we assume that the orientation of the items is fixed, that is, the item length li
should be parallel to the plate length L. Otherwise, we consider each item of size (li, wi) as two different items
of sizes (li, wi) and (wi, li), both with value vi (note that vi = pi for generating patterns for the procedure of Gil-
more and Gomory, and vi = liwi for the greedy constructive heuristic). Let X and Y be the set of non-negative
o

integer linear combinations of the item dimensions along the length L and width W, respectively. Without loss
of generality (Herz, 1972; Christofides and Whitlock, 1977), the possible cuts along L and W are reduced to
th

the elements of sets X and Y (including L and W):

( )
X
m
Au

X ¼ x1 jx1 ¼ ai li ; x1 6 L  l0 ; ai P 0 and integer [ fLg; l0 ¼ min fli g ð4Þ

i¼1;...;m
i¼1
( )
X
m
Y ¼ y 1 jy 1 ¼ ai wi ; y 1 6 W  w0 ; ai P 0 and integer [ fW g; w0 ¼ min fwi g ð5Þ
i¼1;...;m
i¼1

Sets X and Y can be generated in the following way: let f(x1) be a Boolean function with value true if x1 2 X
and false otherwise. Initially f(x1) = true for x1 = li, i = 1, . . . , m and f(x1) = false for x1 < l0. Each one of the
remaining values of f(x1), x1 = l0 + 1, l0 + 2, . . . , L  l0, x1 5 li, is true if at least one of the values in
{f(x1  li), i = 1, . . . , m} is true. A similar procedure can be applied to set Y defining a Boolean function f(y1).
1412 R. Morabito, L. Belluzzo / European Journal of Operational Research 183 (2007) 1405–1420

Let the recursive formulas ft(x, W) and fl(L, y), x 2 X and y 2 Y, be defined as
8 t 9
> f ðkxkX ; W Þ; >
>
> 8 ( ) 9 >
>
>
> > P P > >
>
>
< my < = >
max v i ai ; wi ai 6 W ; ai P 0 and integer ; if x 6 2200; =
t
f ðx; W Þ ¼ max f ðW Þ ¼ fijli ¼xg fijli ¼xg
> >
: >
;>
>
> 0; otherwise >
>
>
> >
>
>
: max fvi bx=li cbW =wi c; li 6 2200g >
;
i¼1;...;m

py
ð6Þ
8 l 9
> f ðx; kykY Þ;
< ( )>
=
f l ðx; yÞ ¼ max P P ð7Þ
> mx
: f ðxÞ ¼ max v i ai ; li ai 6 x; ai P 0 and integer >

co
;
fijwi ¼yg fijwi ¼yg
t l
where f (x, W) = 0 if x = 0, f (x, y) = 0 if x = 0 or y = 0. The notations kxkX and kykY represent the immediate
predecessors of x in X and y in Y, respectively, that is, the largest values in X and Y less than x and y, defined
as kxkX = max{x1 2 Xjx1 < x} and kykY = max{y1 2 Yjy1 < y}. The notation bxc denotes the largest integer
less than or equal to x.
The function ft(x, W) in (6) corresponds to the value of the most valuable pattern with transversal guillotine

al
cuts (i.e., in W) in strip (x, W). This value is equal to the largest value in: (i) ft (kxkX, W), the value of the most
valuable pattern with transversal guillotine cuts in strip (kxkX, W), (ii) fmy(W), the value of the solution of a
on
one-dimensional knapsack problem in W in strip (x, W) (only with items of length li = x), if x 6 2200 mm
(Fig. 6a), (iii) the value of the best homogeneous solution in strip (x, W) (i.e., composed of items of same size
i such that li 6 2200 mm) (Fig. 6b) (see constraint (iii) in Section 2). The restraints x 6 2200 in (ii) and
li 6 2200 in (iii) consider the maximum length of a transversal cut (constraints (i) and (iv) in Section 2). Hence,
rs

the items in the pattern represented by ft(x, W) should have lengths li less than or equal to 2200 mm, otherwise
they could not be cut by the transversal saw.
Similarly, fl(x, y) in (7) corresponds to the value of the most valuable pattern with longitudinal guillotine
pe

cuts (i.e., in x) in strip (x, y). This value is equal to the largest value in: (i) fl(x, kykY), the value of the most
valuable pattern with longitudinal guillotine cuts in strip (x, kykY), (ii) fmx(x), the value of the solution of a
one-dimensional knapsack problem in x in strip (x, y) (only with items of width wi = y). Note that the max-
imum length of 5600 mm of a longitudinal cut (see constraint (i) in Section 2) can be disregarded in the for-
mulas since the hardboard lengths are less than 5600 mm (Section 2).
The one-dimensional knapsack problems in (6) and (7) can be solved by dynamic programming (Martello
r's

and Toth, 1990). Let fimy ðyÞ be the maximum value obtained by combining the widths w1, w2, . . . , wi, i =
1, 2, . . . , m, along width y. Each fimy ðyÞ is defined as fimy ðyÞ ¼ maxffi1my
ðyÞ; vi þ fimy ðy  wi Þg, i = 1, 2, . . . , m,
my
where f0 ðyÞ ¼ 0. Therefore, f my ðW Þ ¼ fmmy ðW Þ in (6). Similarly for fimx ðxÞ and f mx ðxÞ ¼ fmmx ðxÞ in (7).
o

li
li
th

wi
wi
Au

W W

x x
(a) (b)
Fig. 6. (a) Solution of the one-dimensional knapsack problem in W in strip (x, W) (only with items of length li = x); (b) homogeneous
solution in strip (x, W).
 R. Morabito, L. Belluzzo / European Journal of Operational Research 183 (2007) 1405–1420 1413

The best 2-stage guillotine pattern for (x, y) (with the cuts of the first stage parallel to x) can be determined
as a function of fl(x, y) in (7), using the following recursive formula g(x, y) for x 2 X and y 2 Y:
gðx; yÞ ¼ max ff l ðx; y 1 Þ þ gðx; jy  y 1 jY g ð8Þ
0<y 1 6minfy;2200g;y 1 2Y

where g(x, y) = 0 if x = 0 or y = 0. The notations jxjX and jyjY (different of kxkX and kykY) denote the largest
value in X and Y less than or equal to x and y, respectively, that is, jxjX = max{x1 2 Xjx1 6 x} and
jyjY = max{y1 2 Yjy1 6 y}. Note in (8) that the optimal 2-stage pattern for (x, y) combines the most valuable
pattern with longitudinal guillotine cuts (i.e., in x) in strip (x, y1), with the most valuable 2-stage pattern in the

py
remaining strip (x, y  y1) (Fig. 7).
The best pattern with at most k head cuts for (x, W) can be determined as a function of ft (x, W) in (6) and
g(x, y) in (8), using the following recursive formula fk(x, W) for x 2 X, x 6 L  20 mm:

co
fk ðx; W Þ ¼ max ffk1 ðx; W Þ; f t ðx1 ; W Þ þ fk1 ðjx  x1 jX ; W Þg; k ¼ 1; . . . ; 5 ð9Þ
0<x1 6x1000;x1 2X

f0 ðx; W Þ ¼ gðx; W Þ
where fk(x, W) = 0 if x = 0. The kth cut x1 corresponds to the first head cut. The limit k 6 5 refers to the max-
imum number of head cuts that the machine can make (see constraint (iii) in Section 2). The constraint
x  x1 P 1000 mm is the necessary condition for the main book (main part of the pattern) being able to com-

al
plete a turn (constraint (iv) in Section 2). Note in (9) that the optimal pattern with at most k head cuts for
(x, W) combines the most valuable pattern with transversal guillotine cuts (i.e., in W) in strip (x1, W), with
on
the most valuable pattern with at most k1 head cuts in the remaining strip (x  x1, W) (Fig. 8). If k = 0
(no head cuts), then function f0(x, W) is equal to g(x, W). If k = 1, the function f1(x, W) evaluates if
f0(x, W) (no head cuts) is better than ft(x1, W) + f0(jx  x1jX, W) (one head cut at position x1). And so on
if k = 2, . . . , 5, that is, with two, . . . , five head cuts. These head cuts produce particular 3-stage guillotine pat-
rs

terns (constraint (v) in Section 2).

Note in (9) that fk(x, W) is defined for x 6 L  20 mm. For x = L, we should consider the constraint of the
retrim (see constraint (ii) in Section 2), that is, after the last head cut, the saw makes an internal correction cut
pe

of 20 mm in the main part of the pattern (Fig. 9). The complete definition of fk(L, W) is
o r's

Fig. 7. 2-stage guillotine pattern for (x, y).

th
Au

Fig. 8. Pattern with at most k head cuts for (x, W).

1414 R. Morabito, L. Belluzzo / European Journal of Operational Research 183 (2007) 1405–1420

Fig. 9. Pattern with at most k head cuts and retrim of 20 mm for (L, W).

py
fk ðL; W Þ ¼ max ffk1 ðL; W Þ; f t ðx1 ; W Þ þ fk1 ðjL  x1  20jX ; W Þg; k ¼ 1; . . . ; 5 ð10Þ
0<x1 6L100020;x1 2X

co
The formulas ft(x, W) and fl(x, y) in (6) and (7) do not consider the constraint of the maximum number of 4
item sizes in the pattern (due to the limited number of automatic unloading stations; see constraint (vi) in Sec-
tion 2). A simple way to consider this in the greedy constructive heuristic is redefining step (i) of the repeated
exhaustion reduction as (i1) Let M = {1, 2, 3, . . . , m} be a list initially containing all item sizes. (i2) Generate
the best cutting pattern, that is, solve subproblem (P1) for the items in list M. (i3) If the pattern is feasible (i.e.,
the maximum number of item sizes is less than or equal to 4), stop; otherwise, randomly remove from list M

al
one of the item sizes of the pattern (e.g., the one with the smallest demand), and go back to step (i2).
Note that with this modification in step (i), subproblem (P1) may have to be solved more than once in each
iteration of the greedy heuristic. A similar procedure can also be defined to consider such a constraint in the
on
column generation of the simplex algorithm. In the same way, subproblem (P1) may have to be solved more
than once in each simplex iteration. Note that in both cases we are losing generality. As pointed out in Section
2, this constraint can be relaxed if the manual unloading station is in use.
rs

The formulas (6) and (7) above do not also consider the constraint of the maximum number of 4 open
stacks along the sequence of cutting patterns (due to the operation of the pallet devices of the automatic
unloading stations; see constraint (vii) in Section 2). Note that this constraint imposes limitations to the set
pe

of patterns, instead of a single pattern as constraint (vi). Similarly to the discussion above, a simple way to
consider this in the greedy constructive heuristic is redefining step (i) of the repeated exhaustion reduction
as (i1) Let M = {1, 2, 3, . . . , m} be a list initially containing all item sizes. (i2) Generate the best cutting pattern,
that is, solve subproblem (P1) for the items in list M. (i3) If the set of patterns (composed by this pattern and
the patterns generated in the former iterations of the heuristic) is feasible (i.e., the maximum number of open
stacks is less than or equal to 4), stop; otherwise, randomly remove from list M one of the item sizes of the
pattern generated in step (i2), and go back to step (i2). If list M becomes empty, insert an item size randomly
r's

chosen from the items that still have demand in the updated order list. The feasibility of the pattern set can be
verified (approximately) by means of a simple heuristic, for example, heuristic 3 proposed in Yuen (1995).
A similar heuristic procedure can also be defined to consider constraint (vii) in the column generation of the
o

simplex algorithm. In this case, the column generated (cutting pattern) enters into the simplex basis only if the
new basis is feasible, that is, if there is a sequence of the (basic) patterns that opens at most 4 stacks of item
th

sizes. As above, this feasibility can be checked (approximately) applying heuristic 3 of Yuen (1995). Note that
with these procedures, subproblem (P1) may have to be solved more than once in each iteration of the greedy
constructive heuristic, as well as in each iteration of the simplex method. In both cases we are obviously losing
Au

generality. As pointed out in Section 2, this constraint can be relaxed if the manual unloading station is in use,
or the pallet devices of the automatic unloading stations are not operating.

4. Computational results

In this section we present the computational results of the two approaches defined in Section 3: approach 1
(greedy constructive heuristic with pattern generation) and approach 2 (primal simplex algorithm with pattern
generation), to solve an actual industrial example and several randomly generated examples. In both
approaches we use the dynamic programming formulas (9) and (10) to generate a cutting pattern, that is,
to solve subproblem (P1). The one-dimensional knapsack problems in (6) and (7) were also solved by dynamic
 R. Morabito, L. Belluzzo / European Journal of Operational Research 183 (2007) 1405–1420 1415

programming, as discussed in Section 3. To verify if a set of patterns opens at most 4 open stacks of item sizes,
we utilize heuristic 3 in Yuen (1995). To resolve the linear systems of the simplex algorithm, we apply the
Gauss elimination method with partial pivoting. Gilmore and Gomory (1963) recommended the use of a stop-
ping criterion (cutoff) to interrupt the simplex algorithm in cases where, after a few iterations, the improve-
ments in the objective function are insignificant. In this work we implemented the criterion of interrupting
the simplex method as if the last 10 iterations did not reduce the value of the objective function in, at least,
0.1%. Approaches 1 and 2 were coded in Pascal language and implemented in a microcomputer Pentium
IV (512 Mb, 2.8 MHz). A tolerance of ±106 was considered for the floating-point errors.

py
4.1. Experiments with the company example

Table 1 presents the data of the order list provided by the company, with the dimensions of the (identical)

co
hardboards and m = 12 item sizes. As discussed in Section 3, to take into account the saw thickness, we add
6 mm to the dimensions of the hardboards (L, W) and items (li, wi). To consider the border correction cuts, we
reduce the hardboard length by 40 mm (20 mm in each side) and width by 34 mm (17 mm in each side).
Therefore, L reduces from 4880 mm to 4846 mm (i.e., 4880  40 + 6 mm) and W reduces from 2170 mm to
2142 mm (2170  34 + 6 mm). Each item value vi was considered equal to its original area, instead of the area
obtained with the modified item dimensions. The last column of the table refers to the item demands bi. Since

al
there is no fixed orientation for the items, without loss of generality, we consider each item i as two different
items with dimensions (li, wi) and (wi, li), and value vi in the pattern generation (i.e., as a problem with m = 24
item sizes).
on
To produce the ordered demands of Table 1, the company cut 5516 hardboards (58412 m2) in 11 different
cutting patterns with at most 5 head cuts and at most 4 item sizes. There was an overproduction of 413 items,
most of them of item size 3. Considering this overproduction as scrap, this solution yields a global percentage
rs

waste of 14.93%, including trim loss and the material consumed by the border corrections, saw thickness and
retrim. Considering this overproduction as stock for future demand, the global percentage waste reduces to
13.21%. If we discount the material consumed by border corrections, these percentages are 12.86% and
pe

11.11%, respectively.

4.1.1. Approach 1 – Greedy constructive heuristic with pattern generation

Table 2 presents the results obtained by approach 1 for the data of Table 1, for different values of the
parameters: number of iterations of the approach, maximum number of head cuts, maximum number of item
sizes and maximum number of open stacks (of item sizes) in the cutting patterns. The maximum number of
iterations was arbitrarily set to 5. Sets X and Y in (4) and (5) contain 2896 and 313 elements, respectively.
r's

The waste values in the table consider the overproduction of items as stock and they include trim loss and
the material consumed by the saw thickness and retrim. The first and second rows of Table 2 correspond
o

Table 1
Input data of the order list
th

Plate, items i Original lengths (mm) Original widths (mm) Areas vi (m2) Lengths L, li (mm) Widths W, wi (mm) Demands bi
Plate 4880 2170 10.590 4846 2142
1 864 762 0.658 870 768 3000
Au

2 1067 919 0.981 1073 925 1500

3 2032 1219 2.477 2038 1225 10000
4 1220 919 1.121 1226 925 4000
5 1575 762 1.200 1581 768 4000
6 1955 765 1.496 1961 771 750
7 1245 370 0.461 1251 376 2250
8 1245 235 0.293 1251 241 2500
9 1200 465 0.558 1206 471 1000
10 1200 725 0.870 1206 731 1000
11 1105 465 0.514 1111 471 500
12 2130 1375 2.929 2136 1381 2600
1416 R. Morabito, L. Belluzzo / European Journal of Operational Research 183 (2007) 1405–1420

Table 2
Computational results of approach 1
Number Maximum Maximum Maximum Number Number of Item over- Waste Waste
of iterations number of number of number of of hardboards different production (%) (m2)
head cuts item sizes open stacks cut patterns
1 5 4 None 5418 11 14 11.26 6309
5 5 4 None 5290 12 6 9.13 4994
5 5 4 4 5290 12 6 9.13 4994
5 5 None None 5290 12 6 9.13 4994

py
5 0 4 None 5919 11 23 18.76 11,479
5 0 4 4 5919 11 23 18.76 11,479
5 0 None None 5919 11 23 18.76 11,479

co
to solutions with at most 5 head cuts and at most 4 item sizes: the first is the solution of the (pure) repeated
exhaustion reduction (i.e., obtained in the first iteration of approach 1) and the second is the solution of the
refinement discussed at the end of Section 2 (obtained within 5 iterations). Note that, although the number of
different cutting patterns increases from 11 to 12, the improvements provided by the refinement can be signif-
icant (savings of 5418  5290 = 128 hardboards or more than 1300 m2), depending on the production scale of
the cutting process.

al
The third row of Table 2 (obtained within 5 iterations) corresponds to the solution with at most 5 head cuts
and at most 4 open stacks of item sizes. Note that it is the same solution of the second row. Comparing this
on
refined solution with the solution of the company, we note that, although the number of different cutting pat-
terns increases by 1, the number of hardboards used substantially reduces (from 5516 to 5290 plates), as well
as the item overproduction (from 413 to 6 items) and the percentage waste (from 12.86% to 9.14%, considering
overproduction as waste, or from 11.11% to 9.13%, otherwise). A more detailed comparison of these two solu-
rs

tions in terms of item productions and number of times each pattern is cut is presented in Tables 3 and 4.
Table 2 also presents the solutions of approach 1 for the case of no limitations on the number of item sizes
and open stacks in the patterns (fourth row of the table), which is equal to the solution of the second and third
pe

rows (and hence it does not require the operation of the manual unloading station), and for the case of no
head cuts in the patterns (fifth, sixth and seventh rows), which implies that the cutting machine does not need
to rotate the books. Note that the solutions with no head cuts (2-stage guillotine patterns with the cuts of the
first stage parallel to L), despite improving the productivity of the equipment, involve high levels of waste
(18.76%). The computer runtimes to generate the solutions of Table 2 (together with detailed reports of the
cutting patterns) were on the order of minutes.
r's

Table 3
Item productions of the solutions of the company and approaches 1 and 2
o

Plate, items i Lengths Widths Demands Company Approach 1 Approach 2

L, li (mm) W, wi (mm) bi production production production
th

Plate 4846 2142

1 870 768 3000 3000 3002 3004
2 1073 925 1500 1500 1500 1503
3 2038 1225 10,000 10,400 10,000 10,008
Au

4 1226 925 4000 4004 4000 4009

5 1581 768 4000 4001 4001 4002
6 1961 771 750 750 750 750
7 1251 376 2250 2256 2250 2252
8 1251 241 2500 2500 2501 2505
9 1206 471 1000 1000 1000 1000
10 1206 731 1000 1000 1002 1002
11 1111 471 500 501 500 500
12 2136 1381 2600 2601 2600 2601

Total 33,100 33,513 33,106 33,136

 R. Morabito, L. Belluzzo / European Journal of Operational Research 183 (2007) 1405–1420 1417

Table 4
Number of times each pattern is cut and percentage wastes of the solutions of the company and approaches 1 and 2
Pattern j Company Approach 1 Approach 2
Number of times xj Waste (%) Number of times xj Waste (%) Number of times xj Waste (%)
1 650 5.07 750 4.92 582 9.02
2 750 9.21 550 6.65 321 9.15
3 100 10.84 500 7.84 761 8.81
4 2400 13.63 125 8.24 672 10.95

py
5 250 9.96 750 8.39 500 6.89
6 167 7.05 384 9.02 750 4.92
7 567 10.08 500 9.15 74 7.47
8 39 10.96 641 13.68 497 8.39
9 333 7.66 800 10.95 250 7.84

co
10 202 18.86 93 8.57 205 6.50
11 58 19.60 167 14.68 129 3.50
12 30 30.35 486 7.77

Total 5516 11.11 5290 9.13 5227 7.96

al
4.1.2. Approach 2 – Simplex algorithm with pattern generation
Table 5 presents the results obtained by approach 2 for the data of Table 1, for different values of the
parameters: maximum number of head cuts, maximum number of item sizes and maximum number of open
on
stacks in the cutting patterns. The third column corresponds to the number of simplex iterations performed by
the approach. The results of the table were obtained after a simple rounding of the relaxed solution of problem
(P) (each variable value was rounded off to the smallest integer greater than or equal to it). The first row of the
rs

table corresponds to a solution with at most 5 head cuts and at most 4 item sizes. Note that it is better than the
solution of approach 1 (e.g., number of hardboards cut and percentage waste of 5227 and 7.96%, compared to
5290 and 9.13% of approach 1). Since the linear relaxation of problem (P) without rounding provides lower
pe

bounds of 5222 and 7.95%, the solution above, if not optimal, is not far from an optimal. This solution is fea-
sible for the cutting machine if the pallet devices of the automatic unloading stations are turned off, or the
manual unloading station is in use (see constraint (vii) in Section 2), since the best sequence of its patterns
opens 5 stacks of item sizes (this result was verified after analysing all 12! possible cutting pattern sequences).
Note that this solution reduces the global percentage waste from 11.11% to 7.96%, that is, savings of more
than 3% (226 hardboards) if compared with the company solution. A more detailed comparison of this solu-
tion with the solutions of the company and approach 1 is presented in Tables 3 and 4.
r's

The second row of Table 5 corresponds to a solution with at most 5 head cuts and at most 4 open stacks.
Note that this solution (9.14%) is worse than the ones of the first row of Table 5 (7.96%) and the third row of
Table 2 – approach 1 (9.13%), but it is still better than the one of the company (11.11%). Similar to Tables 2
o

and 5 also presents the solutions of approach 2 for the case of no limitations on the number of item sizes and
open stacks in the patterns (third row of the table), which is equal to the solution of the first row, and for the
th

case of no head cuts in the patterns (fourth, fifth and sixth rows), which implies that the cutting machine does
Au

Table 5
Computational results of approach 2
Maximum Maximum Maximum Number of Number of Number of Item over- Waste Waste
number number of number of Iterations hardboards Different production (%) (m2)
of head cuts item sizes open stacks cut patterns
5 4 None 35 5227 12 36 7.96 4302
5 4 4 19 5296 12 42 9.14 5004
5 None None 35 5227 12 36 7.96 4302
0 4 None 22 5906 12 19 18.58 11,346
0 4 4 22 5906 12 19 18.58 11,346
0 None None 22 5906 12 19 18.58 11,346
1418 R. Morabito, L. Belluzzo / European Journal of Operational Research 183 (2007) 1405–1420

not need to rotate the books. Observe that the solutions with no head cuts (2-stage guillotine patterns) result in
high levels of waste (18.58%). The computer runtimes to generate the solutions of Table 5 (together with
detailed reports of the cutting patterns) were on the order of minutes. In order to speed up the approach
(at the expense of producing lower quality solutions), one may limit the sizes of sets X and Y using procedures
described in Beasley (1985) and Morabito and Arenales (1996).

4.2. Experiments with random examples

py
To better evaluate the computational performance of the dynamic programming algorithm (formulas (9)
and (10)) to generate minimum trim loss cutting patterns, we performed an experiment with 5 sets of examples
randomly generated with m= 5, 10, 20, 30 and 50 item sizes, respectively. Each example has dimensions
(L, W) = (4846, 2142) mm and (li, wi), i = 1, . . . , m, uniformly sorted in the intervals [0, 15L, 0, 85L] and

co
[0, 15W, 0, 85W]. This data generation was inspired by the industrial example analysed above. Table 6
resumes the computational results obtained for these 5 datasets (a total of 100 examples). The columns of
the table present the number of item sizes m, the mean and the standard deviation of the area utilization of
the plate (in percentage), the mean number of items arranged in the pattern and the mean computer runtime
(in seconds). Note that as we increase m the runtime substantially increases, but it is still acceptable consid-
ering the decisions involved in production scheduling of the equipment.

al
We also performed an experiment with 10 cutting stock problem instances randomly generated with hard-
board dimensions (L, W) = (4846, 2142) mm and item dimensions (li, wi), i = 1, . . . , m = 10 item sizes, uni-
formly sorted in the intervals [0, 15L, 0, 85L] and [0, 15W, 0, 85W], respectively. Each item demand bi was
on
uniformly sorted in the interval [500, 10000]. We added the saw thickness of 6 mm to the dimensions of the
hardboards (L, W) and items (li, wi). Each item value vi was considered equal to its original area, instead of
the area obtained with the modified item dimensions. We considered that there is no fixed orientation for
rs

the items, that is, each item i was treated as two different items with dimensions (li, wi) and (wi, li), and value
vi in the pattern generation (i.e., as a problem with m = 20 item sizes). The generation of these problem
instances is inspired in a typical company example.
pe

Table 7 compares the average results obtained by applying approaches 1 and 2 to solve these 10 instances.
The columns of the table present the mean area utilization of the plates (in percentage) and the mean computer

Table 6
Computational results of 100 random examples with (L, W) = (4846, 2142) and (li, wi), i = 1, . . . , m, uniformly sorted in the intervals
[0, 15L, 0, 85L] and [0, 15W, 0, 85W]
Dataset m Solution Standard Number of Runtime
r's

value deviation items in the (seconds)

pattern
1 5 0.8287 0.0546 4.75 <0.01
2 10 0.8995 0.0430 6.65 0.02
o

3 20 0.9504 0.0208 8.90 0.63

4 30 0.9659 0.0099 9.85 39.14
th

5 50 0.9796 0.0057 11.05 132.57

Table 7
Au

Computational results of approaches 1 and 2 for the 10 random examples

Maximum Maximum Maximum Approach 1 Approach 2
number of number of number of Solution Runtime Solution Runtime
head cuts item sizes open stacks
value (seconds) value (seconds)
5 4 None 0.8299 140.3 0.8457 112.6
5 4 4 0.8299 150.8 0.8422 128.6
5 None None 0.8299 146.3 0.8457 113.2
0 4 None 0.6846 1.8 0.6864 0.7
0 4 4 0.6846 1.8 0.6864 0.7
0 None None 0.6846 1.8 0.6864 0.7
 R. Morabito, L. Belluzzo / European Journal of Operational Research 183 (2007) 1405–1420 1419

runtime (in seconds). The waste values can be obtained by simply subtracting the area utilization from 1; they
consider the overproduction of items as stock and they include trim loss and the material consumed by the saw
thickness and retrim. Note that approach 2 has a slightly better performance than approach 1. The linear
relaxation of these 10 problems without rounding provides upper bounds on the area utilization very close
to the solution values of Table 7, for example, by relaxing the limits of the number of item sizes and the num-
ber of open stacks, the mean upper bound is 0.85 (i.e., an average waste of 15%). This means that the solutions
of approach 2 in rows 1 and 3, if not optimal, are not far from the optimal.

py
5. Concluding remarks

In this study we have analysed the cutting stock problem of the hardboard industry. In spite of the liter-

co
ature having different approaches to cutting problems, the present problem involves particular constraints
associated with longitudinal and transversal saws, head cuts, book rotation and item unloading stations, that
make the direct application of these approaches difficult. We have presented two approaches to solve the prob-
lem: approach 1 is based on a greedy constructive heuristic and approach 2, on the primal simplex method
with column generation. Both approaches utilise recursive formulas of dynamic programming to generate fea-
sible cutting patterns for the cutting machine.
To illustrate the application of these approaches, we solved an actual example provided by a Brazilian hard-

al
board company, as well as randomly generated examples. The two approaches were able to produce good
results in comparison to the ones used by the company, in some cases with savings of more than 3% in the
on
overall waste. Due to the production scale of hardboard cutting processes, small percentage waste reductions
of the cutting patterns may result in substantial savings for this industry. We believe that these approaches
may also be useful to deal with cutting problems in other industrial processes involving constraints similar
to those analysed here.
rs

The proposed approaches (in their current states) consider the pallet device constraints of the automatic
unloading stations using simple heuristic procedures. These constraints are related to an NP-hard problem
of sequencing cutting patterns, called the maximum number of open stacks problem. Sequencing decisions
pe

can be ignored if the pallet devices of the automatic unloading stations are not operating, or the manual
unloading station is in use. If this is not the case, integrating cutting and sequencing decisions result in a dif-
ficult problem (Pileggi et al., 2005; Yanasse and Lamosa, 2005). Besides the limitation of the maximum num-
ber of open stacks of the items, other aspects such as due dates, intermediary stocks, etc., may need to be
accounted for when generating and sequencing cutting patterns in the hardboard industry. An interesting per-
spective for future research is the development of more elaborate and effective procedures to incorporate
r's

sequencing decisions in approaches 1 and 2.

Acknowledgements
o

The authors thank the two anonymous referees and Profs. Marcos Arenales and Maria S. Rangel for their
helpful comments and suggestions. This research was partially supported by CNPq (grant 522973/95-7), FA-
th

PESP (grants 9522-0 and 01/2972-2).

Au

References

Arenales, M., Morabito, R., Yanasse, H. (Eds). 1999. Special issue: Cutting and packing problems. Pesquisa Operacional 19, 109–284.
Beasley, J., 1985. Algorithms for unconstrained two-dimensional guillotine cutting. Journal of the Operational Research Society 36, 297–
306.
Becceneri, J., Yanasse, H., Soma, N., 2004. A method for solving the minimization of the maximum number of open stacks problem
within a cutting process. Computers and Operations Research 31, 2315–2332.
Belluzzo, L., 2002. Otimização nos planos de corte de chapas de fibra de madeira reconstituı´da: Um estudo de caso na programação da
produção da serra Holzma. Dissertation, Departamento de Engenharia de Produção, Universidade Federal de São Carlos, São Carlos,
SP, Brazil.
Bischoff, E., Waescher, G. (Eds.), 1995. Special issue on cutting and packing problems. European Journal of the Operational Research
84(3), 503–712.
1420 R. Morabito, L. Belluzzo / European Journal of Operational Research 183 (2007) 1405–1420

Christofides, N., Whitlock, C., 1977. An algorithm for two-dimensional cutting problems. Operations Research 25 (1), 30–44.
Dowsland, K., Dowsland, W., 1992. Packing problems. European Journal of Operational Research 56, 2–14.
Dyckhoff, H., 1990. A typology of cutting and packing problems. European Journal of the Operational Research 44, 145–159.
Dyckhoff, H., Finke, U., 1992. Cutting and packing in production and distribution. Springer-Verlag, Heildelberg.
Dyckhoff, H., Scheithauer, G., Terno, J., 1997. Cutting and packing. In: Amico, M., Maffioli, F., Martello, S. (Eds.), Annotated
Bibliographies in Combinatorial Optimisation. John Wiley, New York, pp. 393–414.
ESICUP – EURO Special Interest Group on Cutting and Packing, http://www.apdio.pt/esicup/ (accessed in 2005).
Gilmore, P., Gomory, R., 1961. A linear programming approach to the cutting stock problem. Operations Research 9, 849–859.
Gilmore, P., Gomory, R., 1963. A linear programming approach to the cutting-stock problem II. Operations Research 11, 863–888.
Gilmore, P., Gomory, R., 1965. Multistage cutting stock problems of two and more dimensions. Operations Research 14, 94–120.

py
Herz, J.C., 1972. Recursive computational procedure for two-dimensional cutting. IBM Journal of Research and Development 16, 462–
469.
Hifi, M. (Ed.), 2002. Special issue: Cutting and packing problems. Studia Informatica Universalis 2(1), 1–161.
Hinxman, A.I., 1980. The trim loss and assortment problems: A survey. European Journal of Operational Research 5, 8–18.

co
Lodi, A., Martello, S., Monaci, M., 2002. Two-dimensional packing problems: a survey. European Journal of Operational Research 141,
241–252.
Martello, S. (Ed.), 1994. Special issue: Knapsack, packing and cutting, Part II: Multidimensional knapsack and cutting stock problems.
INFOR 32, 4.
Martello, S., Toth, P., 1990. Knapsack problems: Algorithms and computer implementations. John Wiley, Chichester.
Morabito, R., Arenales, M., 1996. Staged and constrained two-dimensional guillotine cutting problems: An and/or-graph approach.
European Journal of Operational Research 94, 548–560.

al
Morabito, R., Arenales, M., 2000. Optimizing the cutting of stock plates in a furniture company. International Journal of Production
Research 38 (12), 2725–2742.
Morabito, R., Garcia, V., 1998. The cutting stock problem in a hardboard industry: A case study. Computers and Operations Research 25
(6), 469–485.
on
Pileggi, G., Morabito, R., Arenales, M., 2005. Integrated optimization of the generation and sequencing of cutting patterns in the cutting
stock problem. European Journal of Operational Research (submitted).
Sweeney, P., Paternoster, E., 1992. Cutting and packing problems: A categorized, application-oriented research bibliography. European
Journal of the Operational Research 43, 691–706.
rs

Waescher, G., Haussner, H., Schumann, H., 2006. An improved typology of cutting and packing problems. European Journal of
Operational Research, this issue, doi:10.1016/j.ejor.2005.12.047.
Wang, P., Waescher, G. (Eds.), 2002. Special issue on cutting and packing. European Journal of Operational Research 141(2), 239–469.
Yanasse, H., 1997. On a pattern sequencing problem to minimise the maximum number of open stacks. European Journal of Operational
pe

Research 100 (3), 454–463.

Yanasse, H., Lamosa, M.J., 2005. An integrated cutting stock and sequencing problem. European Journal of Operational Research, this
issue, doi:10.1016/j.ejor.2005.09.054.
Yanasse, H., Zinober, A., Harris, R., 1991. Two-dimensional cutting stock with multiple stock sizes. Journal of the Operational Research
Society 42, 673–683.
Yuen, B.J., 1995. Improved heuristics for sequencing cutting patterns. European Journal of Operational Research 87, 57–64.
o r's
th
Au