PhD Pietrobuoni

PhD Pietrobuoni
Alma Mater Studiorum Università di Bologna
DEI - Dipartimento di Ingegneria dell’Energia Elettrica e dell’Informazione
“Guglielmo Marconi ”
Dottorato di Ricerca in Automatica e Ricerca Operativa
Ciclo XXVI
Settore concorsuale di afferenza: 01/A6 - RICERCA OPERATIVA
Settore scientifico disciplinare: MAT/09 - RICERCA OPERATIVA
Two-Dimensional Bin Packing Problem
with Guillotine Restrictions
Enrico Pietrobuoni
Coordinatore
Relatore
Prof. Daniele Vigo
Prof. Andrea Lodi
Ing. Michele Monaci
Esame Finale 2015
Contents
List of Figures
v
1 Outline
1
2 The
2.1
2.2
2.3
2.4
2.5
2.6
2.7
2.8
2.9
Two-Dimensional Bin Packing Problem
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Cutting and Packing . . . . . . . . . . . . . . . . . . . . . . . .
Rectangle Packing Problem . . . . . . . . . . . . . . . . . . . .
Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.5.1 One-dimensional bin packing problem . . . . . . . . . .
2.5.2 Two-dimensional bin packing problem . . . . . . . . . .
2.5.3 ILP models for level packing . . . . . . . . . . . . . . .
The asymptotic and the absolute worst-case performance ratios
Upper Bounds . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.7.1 Strip packing . . . . . . . . . . . . . . . . . . . . . . . .
2.7.2 Bin packing: Two-phase heuristics . . . . . . . . . . . .
2.7.3 Bin packing: One-phase level heuristics . . . . . . . . .
2.7.4 Bin packing: One-phase non-level heuristics . . . . . . .
2.7.5 Metaheuristics . . . . . . . . . . . . . . . . . . . . . . .
2.7.6 Approximation algorithms . . . . . . . . . . . . . . . . .
Lower Bounds . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Exact Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . .
3 Two-Dimensional Bin Packing: the
3.1 Introduction . . . . . . . . . . . . .
3.1.1 Our goals . . . . . . . . . .
3.1.2 Definitions . . . . . . . . .
3.1.3 Convexification Algorithm .
3.1.4 Algorithm and assumptions
3.2 Smallest non-separable pattern . .
3.2.1 Rows and Intersections . .
3.3 Blocked Ring . . . . . . . . . . . .
3.3.1 Detecting a Blocked Ring .
3.4 Blocked Ring characterization . . .
3.4.1 Single Blocked Ring . . . .
3.4.2 Multiple Blocked Ring . . .
2BP|O|G
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
case
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3
3
4
4
6
7
7
7
9
11
11
12
15
17
18
19
23
24
28
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
31
31
32
33
34
37
38
38
41
41
48
48
49
3.5
Worst-case analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.5.1 Case 1: P is a Simple Blocked Ring . . . . . . . . . . . . . . . . 53
3.5.2 Case 2: P is a Single Blocked Ring . . . . . . . . . . . . . . . . . 53
4 Partial enumeration algorithms for 2BP|O|G
4.1 Introduction . . . . . . . . . . . . . . . . . . .
4.2 Basic Heuristic Algorithm . . . . . . . . . . .
4.2.1 Packing the current bin . . . . . . . .
4.2.2 Selection rule . . . . . . . . . . . . . .
4.2.3 Guillotine split rule . . . . . . . . . .
4.3 Enhanced Heuristic Algorithm . . . . . . . .
4.3.1 Removing duplicated nodes . . . . . .
4.3.2 Heuristic pruning . . . . . . . . . . . .
4.4 Computational experiments . . . . . . . . . .
4.5 Conclusions . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
59
59
61
61
62
63
64
64
64
65
69
List of Figures
2.1
2.2
2.3
2.4
2.5
2.6
2.7
2.8
2.9
2.10
2.11
2.12
Fekete and Schepers modeling approach. . . . . .
Three classical strategies for the level packing. . .
Algorithm HFF. . . . . . . . . . . . . . . . . . . .
Algorithm FBS. . . . . . . . . . . . . . . . . . . . .
Algorithm FC. . . . . . . . . . . . . . . . . . . . .
Algorithm FNF. . . . . . . . . . . . . . . . . . . .
Algorithm FFF. . . . . . . . . . . . . . . . . . . . .
Algorithm FBL. . . . . . . . . . . . . . . . . . . . .
Algorithm NBL. . . . . . . . . . . . . . . . . . . .
Algorithm AD. . . . . . . . . . . . . . . . . . . . .
Worst-case of the area bound. . . . . . . . . . . . .
(a) items in I1 , I2 and I3 ; (b) relaxed instance with
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
9
13
15
16
17
18
18
19
19
20
25
26
3.1
3.2
3.3
3.4
3.5
3.6
Example of guillotine pattern. . . . . . . . . . . . . . . . . . . . . . . .
The convexification algorithm. . . . . . . . . . . . . . . . . . . . . . .
Convexification algorithm: step 2. . . . . . . . . . . . . . . . . . . . .
Convexification algorithm: step 3. . . . . . . . . . . . . . . . . . . . .
Convexification algorithm: step 5. . . . . . . . . . . . . . . . . . . . .
Convexification Algorithm on a separable pattern that produces a nonseparable pattern. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Patterns with 3 items. . . . . . . . . . . . . . . . . . . . . . . . . . . .
Patterns with 4 items. . . . . . . . . . . . . . . . . . . . . . . . . . . .
The packing algorithm. . . . . . . . . . . . . . . . . . . . . . . . . . .
Separable and non-separable rows. . . . . . . . . . . . . . . . . . . . .
Pattern with 5 items, x = 3 and y = 1. . . . . . . . . . . . . . . . . . .
Patterns with 5 items: xh = 4, xv = 0 e y = 0, xh = 3, xv = 1 e y = 0.
Simple Blocked Ring. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Two examples where we apply the algorithm to detect Blocked Ring. .
Step 1: Items interested by the selected vertical rows (ex.1). . . . . . .
Step 1: Items interested by the selected vertical rows (ex.2). . . . . . .
Step 1: Items interested by the selected horizontal rows (ex.1). . . . .
Step 1: Items interested by the selected horizontal rows (ex.2). . . . .
Step 2: Items to keep (ex.1). . . . . . . . . . . . . . . . . . . . . . . .
Step 2: Items to keep (ex.2). . . . . . . . . . . . . . . . . . . . . . . .
Step 3: Items after Convexification Algorithm execution (ex.1). . . . .
Step 3: Items after Convexification Algorithm execution (ex.2). . . . .
Edge-to-edge cut on a non-separable rows pattern. . . . . . . . . . . .
How to place row C. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
33
34
34
35
35
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
36
37
37
38
39
40
40
40
42
42
43
43
43
43
44
44
44
45
46
3.7
3.8
3.9
3.10
3.11
3.12
3.13
3.14
3.15
3.16
3.17
3.18
3.19
3.20
3.21
3.22
3.23
3.24
v
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
reduced
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
items.
.
.
.
.
.
.
.
.
.
.
.
.
3.25
3.26
3.27
3.28
3.29
3.30
3.31
3.32
How to place row D (case 1). . . .
How to place row D (case 2). . . .
Single Blocked Ring. . . . . . . . .
Nested Blocked Ring. . . . . . . .
Concatenated Blocked Ring. . . . .
Complex Blocked Ring. . . . . . .
Non guillotinable pattern. . . . . .
Worst-case for problem P1 when P
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
is a Single
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
Blocked
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
Ring.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
47
47
48
49
50
51
52
54
4.1
4.2
4.3
Example of non guillotine and guillotine patterns. . . . . . . . . . . . . . 60
Algorithm to pack a single bin. . . . . . . . . . . . . . . . . . . . . . . . 62
Example of horizontal (left) and vertical (right) guillotine cut. . . . . . . 63
List of Tables
4.1
4.2
4.3
Results on 2BP instances from the literature for the basic algorithm. . . 67
Results on 2BP instances from the literature for the enhanced algorithm
with N1 = 500, N2 = 500 and δ = 0.1. . . . . . . . . . . . . . . . . . . . 68
Comparison between guillotine and non-guillotine heuristics. Time limit
= 1,800 CPU seconds. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
vii
Keywords
• Cutting and Packing
• Bin Packing Problem
• Guillotine Restrictions
• Worst-Case Performance Ratios
• Blocked Ring
• Heuristic Algorithms
A chi mi ha incoraggiato, consigliato, supportato.
Ad Alberto.
Acknowledgements
I want to deeply thank my thesis advisors, Professor Andrea Lodi, for his thoughtful guidance and warm encouragement and Dr. Michele Monaci who supported and
advised my research with precious contributions.
Lastly, I want to express my gratitude to Professor Alberto Caprara, a brilliant scientist, for his lasting belief in me.
Chapter 1
Outline
The Two-Dimensional Bin Packing Problem (2BP) is the problem of packing, without
overlapping, a given set of small rectangles, called items, into the minimum number of
identical large rectangles, called bins, with the edges of the items parallel to those of
the bins.
The great interest of 2BP is mainly due to the large number of real-world applications
in which it arises: from industry to computer system and networking, and depending
on these applications, 2BP can be found in the literature with the addition of different
practical requirements (orientation, levels, guillotine cuts...) which originate many
interesting variants.
In particular in this thesis, according to the three-field notation proposed in Lodi,
Martello, Vigo [53], we will denote by 2BP|O|G the Two-Dimensional Bin Packing
Problem with Guillotine Restriction, i.e. where it is imposed that items are obtained
through a sequence of edge-to-edge cuts parallel to the edges of the bin and cannot
be rotated. Similarly, the problem in which guillotine constraint is not imposed and
items are oriented, no rotation allowed, will be denoted as 2BP|O|F.
In Chapter 2 we present recent advances obtained for the two-dimensional bin packing
problem. In Chapter 3 a mathematical characterization of non-guillotine patterns is
provided and the relation between the 2BP|O|G solution value and the 2BP|O|F is
being studied from a worst-case perspective.
Finally in Chapter 4 we present a new heuristic algorithm, for the 2BP|O|G, based on
partial enumeration, and computationally evaluate its performance on a large set of
instances from the literature.
1
Chapter 2
The Two-Dimensional Bin
Packing Problem
2.1.
Introduction
In the two-dimensional bin packing problem (2BP) we are given a set of n rectangular
items j ∈ J = {1, . . . , n}, each having width wj and height hj , and an unlimited number
of finite identical rectangular objects called bins, having width W and height H. The
problem is to allocate all the items, without overlapping, to the minimum number of
bins. It is the two-dimensional extension of the classic one-dimensional bin packing
problem (1BP), and is one of the most studied problem in the so called Cutting &
Packing category.
In this chapter we survey recent advances obtained for the two-dimensional bin packing
problem. We start by reviewing main rectangular packing problems and their applications in Sections 2.3, 2.4, then we will present the classical mathematical models in
Section 2.5 which have relevant implications on the topic of the present chapter, and
discuss more recent results. We will proceed with the definition of the asymptotic and
the absolute worst-case performance ratios in Section 2.6 and upper bounds in Section 2.7, including metaheuristics and approximation algorithms. Finally the last two
sections are dedicated to lower bounds in Section 2.8 and exact algorithms in Section
2.9.
The structure of this chapter is based on: Lodi, Martello and Vigo [55] and Lodi,
Martello and Monaci [50].
3
4
Chapter 2 The Two-Dimensional Bin Packing Problem
2.2.
Cutting and Packing
Cutting and packing problems consist of placing a given set of (small) items into one
or more (larger) objects without overlap in order to maximize or minimize a given objective function. These are combinatorial optimization problems with many important
industrial applications, especially in cutting (e.g., wood, glass, steel, leather and paper
industries) and packing (e.g., transportation, telecommunication and warehousing).
Cutting and packing problems can be classified using different criteria:
• Dimension: most problems are defined over one, two or three dimensions. In
this chapter we mainly consider two-dimensional problems.
• Shape: it refers to items and objects shape. When the shapes of items to be
packed are polygons or arbitrary shapes the problem is called irregular packing. We instead focus on rectangle packing where both items and objects are
rectangles.
2.3.
Rectangle Packing Problem
In the two-dimensional rectangle packing problem we are given a set of n rectangular
items j ∈ J = {1, . . . , n}, each having width wj and height hj , and one or many rectangular objects. We are required to place the items orthogonally without any overlap (an
edge of the item is parallel to an edge of the object) so as to minimize (or maximize) a
given objective function. The rectangle packing problem can be characterized by two
important constraints:
• Orientation: each items has a given fixed orientation, i.e. rotation by 90◦ is not
allowed. This is the case of newspaper paging or when the items are decorated
or corrugated.
• Guillotine cut: items must be obtained through a sequence of edge-to-edge
cuts parallel to the edge of the large rectangular object. Guillotine cut is usually imposed by technical limitations of the automated cutting machines or the
material.
We introduce six types of rectangular packing problems that have been actively studied.
For simplicity, we define the problem assuming that each item has a fixed orientation
and the guillotine cut constraint is not imposed unless otherwise stated.
The first two problems are characterized by one large rectangular object, which may
grow in one or two dimensions, where all the items are to placed disjointly.
Chapter 2 The Two-Dimensional Bin Packing Problem
5
Strip packing problem (2SP): we are given a set of n rectangular items j ∈ J =
{1, . . . , n}, each having width wj and height hj , and one large object called strip whose
width W is fixed and height H is variable. The object is to minimize the height H of
the strip such that all the items can be packed into the strip.
Area minimization problem (2AP): we are given a set of n rectangular items
j ∈ J = {1, . . . , n}, each having width wj and height hj , and one large rectangular
object, where both its width W and height H are variables. The object is to minimize
the area W H of the object such that all the items can be packed into the object.
The next two problems have one or many fixed size objects.
Two-dimensional bin packing problem (2BP): we are given a set of n rectangular
items j ∈ J = {1, . . . , n}, each having width wj and height hj , and an unlimited number
of finite identical rectangular objects called bins, having width W and height H. The
problem is to allocate all the items to the minimum number of bins.
The special case where wj = W (j = 1, . . . , n) is the famous one-dimensional bin
packing problem (1BP): partition n elements, each having an associated size hj , into
the minimum number of subsets so that the sum of the sizes in each subset does not
exceed a given capacity H. Since 1BP is known to be strongly NP-hard, the same
holds for 2BP.
The requirements of orientation and guillotine cut, already mentioned, generate the
following class (see Lodi, Martello, Vigo [53]) of 2BP problems:
2BP|O|G: the items are oriented (O), and guillotine cut (G) is required;
2BP|R|G: the items may be rotated by 90◦ (R) and guillotine cut is required;
2BP|O|F: the items are oriented and cutting is free (F);
2BP|R|F: the items may be rotated by 90◦ and cutting is free.
Two-dimensional knapsack problem (2KP): we are given a set of n rectangular
items j ∈ J = {1, . . . , n}, each having width wj , height hj , and profit pj and a rectangular knapscak with width W and height H. The objective is to find a subset J 0 ⊆ J
P
of items with the maximum total value j∈J 0 pj such that all the items j ∈ J 0 can be
packed into the knapsack.
The last two problems are useful for modeling situations related to industrial applications, such as mass production manufacturing, many small items of an identical shape
or relatively few classes of shapes are packed into the objects.
Two-dimensional cutting stock problem (2CP): we are given a set of n rectangular items j ∈ J = {1, . . . , n}, each having width wj , height hj , and demand dj and
an unlimited number of finite identical rectangular objects called bins, having width
6
Chapter 2 The Two-Dimensional Bin Packing Problem
W and height H. The problem is to allocate all the items to the minimum number of
bins (i.e., for each j, we place dj copies of item j into the bins).
Pallet loading problem (2PLP): we are given sufficiently large number of items
with identical size (w, h), and one large rectangular object with size (W, H). The
objective is to place the maximum number of items into the object, where each item
can be rotated by 90◦ .
The complexity of the PLP is open, i.e. this problem isn’t known to be in class NP,
because of the compact input description, whereas the other problems we defined are
known to be NP-hard.
Without loss of generality, we will assume that all input data are positive integers, and
that wj ≤ W and hj ≤ H (j = 1, . . . , n).
2.4.
Applications
Classical bin packing has a large number of applications [35], from industry (cutting
material such us cables, lumber or paper) to computer systems (memory allocation
in paged computer systems) and networking (packet routing in communication networks). Effectively, bin packing appears as a sub-problem in various other settings.
Most importantly, in manufacturing settings rectangular pieces need to be cut out of
some sheet of raw material, while minimizing the waste. Obviously, cutting problems
and packing problems correspond to each other. Restrictions to orthogonal packing
and packing with restricted or even without rotations make sense in this setting as
well if we cut items out of patterned fabric and have to retain the alignment of the
pattern. These cutting stock problems occur as bin packing and strip packing problems. Scheduling independent tasks on a group of processors, each requiring a certain
number of contiguous processors or memory allocation during a certain length of time,
can also be modeled as a strip packing problem [47]. In this application the width of
the strip represents the total number of processors or memory available, and the height
represents the maximal completion time. Thinking of (semi-)manually operated machines instead of processors we might have periodic breaks, as they would occur when
working in shifts, making this a two-dimensional bin packing problem. Further applications can also be found in VLSI-design (minimum rectangle placement problem [63])
and in the advertisement placement problem [29]. In this problem, we have to place
all given rectangular ads on a minimal number of pages or web-pages.
Chapter 2 The Two-Dimensional Bin Packing Problem
2.5.
Models
2.5.1
One-dimensional bin packing problem
7
The 1BP can be described as follows. Given n items each having an associated size hj
and n bins, with capacity H, a possible mathematical formulation of the problem is
(1BP)
n
X
min
i=1
n
X
subject to
j=1
n
X
yi
(2.1)
hj xij ≤ Hyi
(i = 1, . . . , n)
(2.2)
xij = 1
(j = 1, . . . , n)
(2.3)
(i = 1, . . . , n)
(2.4)
i=1
yi ∈ {0, 1}
xij ∈ {0, 1}
where
(
xij =
(2.5)
1 if bin i is used
0 otherwise
(2.6)
1 if item j is assigned to bin i
0 otherwise
(2.7)
yi =
(
(i = 1, . . . , n)(j = 1, . . . , n)
We will suppose, as is usual, that hj are positive integers. Hence, without loss of
generality, we will also assume that H is a positive integer and hj ≤ H, j = {1, . . . , n}.
If an item violates the last assumption, then the instance is trivially infeasible.
2.5.2
Two-dimensional bin packing problem
The first attempt to model two-dimensional packing problems was made by Gilmore
and Gomory [32], through an extension of their approach to 1BP (see [30],[31]) . They
proposed a column generation approach (see Lübbecke and Desrosiers [58] for a recent
survey) based on the enumeration of all subsets of items (patterns) that can be packed
into a single bin. Let Aj be a binary column vector of n elements aij (i = 1, . . . , n)
taking the value 1 if item i belongs to the j-th pattern, and the value 0 otherwise.
The set of all feasible patterns is then represented by the matrix A, composed by all
8
Chapter 2 The Two-Dimensional Bin Packing Problem
possible Aj columns (j = 1, . . . , M ), and the corresponding mathematical model is
(2BP − GG)
min
M
X
xj
(2.8)
j=1
subject to
M
X
aij xj ≥ 1
(i = 1, . . . , n)
(2.9)
j=1
xj ∈ {0, 1}
(j = 1, . . . , M )
(2.10)
where xj takes the value 1 if pattern j belongs to the solution, and the value 0 otherwise.
Observe that (2.8)–(2.10) is a valid model for 1BP as well, the only difference being
P
that the Aj ’s are all columns satisfying ni=1 aij hi ≤ H.
Due to the immense number of columns that can appear in A, the only way for handling
the model is to dynamically generate columns when needed. While for 1BP Gilmore
and Gomory [30, 31] gave a dynamic programming approach to generate columns by
solving, as a slave problem, an associated 0-1 knapsack problem (see Martello and Toth
[71]), for 2BP they observed the inherent difficulty of the two-dimensional associated
problem. Hence, they switched to the more tractable case where the items have to
be packed in rows forming levels (see Section 2.5.3), for which the slave problem was
solved through a two-stage dynamic programming algorithm.
Beasley [4] considered a two-dimensional cutting problem in which a profit is associated
with each item, and the objective is to pack a maximum profit subset of items into
a single bin (two-dimensional knapsack problem). He gave an ILP formulation based
on the discrete representation of the geometrical space and the use of coordinates at
which items may be allocated, namely
(
xipq =
1 if item i is placed with its bottom left hand corner at (p, q)
0 otherwise
(2.11)
for i = 1, . . . , n, p = 0, . . . , W − wi and q = 0, . . . , H − hi . A similar model, in which p
and q coordinates are handled through distinct decision variables, has been introduced
by Hadjiconstantinou and Christofides [34]. Both models are used to provide upper
bounds through Lagrangian relaxation and subgradient optimization.
A completely different modeling approach has been proposed by Fekete and Schepers
[24], through a graph-theoretical characterization of the packing of a set of items into
a single bin. Let Gw = (V, Ew ) (resp. Gh = (V, Eh )) be an interval graph having a
vertex vi associated with each item i in the packing and an edge between two vertices
(vi , vj ) if and only if the projections of items i and j on the horizontal (resp. vertical)
axis overlap (see Figure 2.1). It is proved in [24] that, if the packing is feasible then
(a) for each stable set S of Gw (resp. Gh ),
P
vi ∈S
wi ≤ W (resp.
P
vi ∈S
hi ≤ H);
Chapter 2 The Two-Dimensional Bin Packing Problem
9
(b) Ew ∩ Eh = ∅.
This characterization easily extends to packings in higher dimensions.
4
4
4
3
1
3
1
2
2
@
@
3
1
@
@
2
4
1
3
2
3
4
2
Figure 2.1: Fekete and Schepers modeling approach.
2.5.3
1
ILP models for level packing
ILP models involving a polynomial number of variables and constraints have been
obtained by Lodi, Martello and Vigo [56] for the special case where the items have to
be packed “by levels”.
As will be seen in the next section, most of the approximation algorithms for 2BP and
2SP pack the items in rows forming levels. The first level is the bottom of the bin, and
items are packed with their base on it. The next level is determined by the horizontal
line drawn on the top of the tallest item packed on the level below, and so on. Note
that we do not require that all items in a level have the same height. Let us denote by
2LBP problem 2BP restricted to this kind of packing.
We assume in the following, without loss of generality, that only normalized packings
are considered, i.e., packings such that:
(i) in each level, the leftmost item is the tallest one;
(ii) the items are sorted and re-numbered by non-increasing hj values.
10
Chapter 2 The Two-Dimensional Bin Packing Problem
We will say that the leftmost item in a level (resp. the bottom level in a bin) initializes
the level (resp. the bin).
Problem 2LBP can be efficiently modeled by assuming that there are n potential levels
(the i-th one associated with item i initializing it), and n potential bins (the k-th one
associated with potential level k initializing it). Hence let yi , i ∈ J (resp. qk , k ∈ J) be
a binary variable taking the value 1 if item i initializes level i (resp. level k initializes
bin k), and the value 0 otherwise. The problem can thus be modeled as
(2LBP)
min
subject to
n
X
k=1
j−1
X
qk
(2.12)
xij + yj = 1
i=1
n
X
wj xij
≤ (W − wi )yi
(j = 1, . . . , n)
(2.13)
(i = 1, . . . , n − 1) (2.14)
j=i+1
i−1
X
zki + qi = yi
k=1
n
X
hi zki
≤ (H − hk )qk
(i = 1, . . . , n)
(2.15)
(k = 1, . . . , n − 1)(2.16)
i=k+1
yi , xij , qk , zki ∈ {0, 1}
∀ i, j, k
(2.17)
where xij , i ∈ J \ {n} and j > i (resp. zki , k ∈ J \ {n} and i > k) takes the value 1 if
item j is packed in level i (resp. level i is allocated to bin k), and the value 0 otherwise.
Restrictions j > i and i > k easily follow from assumptions (i)–(ii) above. Equations
(2.13) and (2.15) impose, respectively, that each item is packed exactly once, and that
each used level is allocated to exactly one bin. Equations (2.14) and (2.16) impose,
respectively the width constraint to each used level and the height constraint to each
used bin.
Computational experiments have shown that the above model is quite useful in practice. Its direct use with a commercial ILP solver produces very good solutions (and, in
many cases, the optimal solution) to realistic sized instances within short CPU times.
In addition, several variants of the problem can be easily handled by modifying some
of the constraints, or by adding linear constraints to the models.
The set covering model (2.8)-(2.10) can be adapted to 2LBP, and to the level version of
2SP (see, e.g., Bettinelli, Ceselli and Righini [6]). In this case, each column corresponds
to a set of items which can be inserted into a shelf, and the associated pricing problem
turns out to be a simple variant of the knapsack problem.
Chapter 2 The Two-Dimensional Bin Packing Problem
2.6.
11
The asymptotic and the absolute worst-case performance ratios
Due to the difficult of solving packing problems to optimality, heuristic algorithms
are of interest to solve these problems. The performance of an algorithm can be
measured by the worst-case and the average-case performance as in Simchi-Levi, Chen
and Bramel [19]. Worst case analysis shows how poor a heuristic algorithm can be
when it builds the worst solution compare to the best possible one. The deviation
from the worst-case solution to the optimal solution represents the performance of
the heuristic. However, a heuristic that builds a poor worst-case solution may not
generate a poor solution in general. Consequently, the average-case analysis, which
is the probabilistic analysis, is an alternative method to determinate the performance
of the heuristic methods. For example, when the distribution of the size of items is
known, there are two ways to determinate the average-case performance. First, the
analytical method which is quite often very difficult, second the empirical tests which
run on several instances and replications.
For what concern the worst-case ratio we have two types. Several denominations and
definitions can be found in literature for the asymptotic and the absolute worst-case
ratio. They both measure the gap between the solution value found by an algorithm
and the optimum in the worst-case.
Formally, given a minimization problem Π, an instance I ∈ Π of the problem, and
an algorithm A, the value of the solution yielded by the algorithm is A(I) and the
optimum is OP T (I). The asymptotic worst-case performance ratio is the smallest
positive R∞ such that the following relation holds for any instance of the problem:
A(I) ≤ R∞ · OP T (I) + O(1),
∀I ∈ Π
(2.18)
The absolute worst-case performance ratio is the smallest positive ρ such that the
following relation holds for any instance of the problem:
A(I) ≤ ρ · OP T (I),
2.7.
∀I ∈ Π
(2.19)
Upper Bounds
Heuristics algorithms for the two-dimensional bin packing are divided in off-line and
on-line algorithms. In the on-line version the items are given to the on-line algorithm
one by one from a list, and the next items is given as soon as the current items is
irrevocably placed. While in the off-line version it is assumed that the algorithm has
12
Chapter 2 The Two-Dimensional Bin Packing Problem
full knowledge of the whole input.
The most popular on-line algorithms are the next fit, first fit and best fit strategies,
which are extended from the algorithms for the one-dimensional packing problem.
Since we will present the strategies of the off-line algorithms which are based on next
fit, first fit and best fit strategies we don’t go through them. For a detailed survey on
on-line algorithms refer to Csirik and Woeginger [18].
Most of the off-line heuristic algorithms from the literature are of greedy type, and can
be classified in two families:
• one-phase algorithms directly pack the items into the finite bins;
• two-phase algorithms start by packing the items into a single strip of width W .
In the second phase, the strip solution is used to construct a packing into finite
W × H bins.
In addition, most of the approaches are level algorithms. Before describing one and
two-phase algorithms, we need to briefly introduce algorithms for packing the items
into a strip.
2.7.1
Strip packing
In the two-dimensional strip packing problem one is required to pack all the items into
a strip of minimum height. Three classical strategies, based on level packing, have
been derived from famous algorithms for the one-dimensional case. In each case, the
items are initially sorted by non-increasing height and packed in the corresponding
sequence. Let j denote the current item, and s the last created level:
• Next-Fit Decreasing Height (NFDH) strategy: item j is packed left justified on
level s, if it fits. Otherwise, a new level (s := s + 1) is created, and j is packed
left justified into it;
• First-Fit Decreasing Height (FFDH) strategy: item j is packed left justified on
the first level where it fits, if any. If no level can accommodate j, a new level is
initialized as in NFDH;
• Best-Fit Decreasing Height (BFDH) strategy: item j is packed left justified on
that level, among those where it fits, for which the unused horizontal space is a
minimum. If no level can accommodate j, a new level is initialized as in NFDH.
As we will see, the three strategies above are also used as a first step in the two-phase
algorithms for two-dimensional bin packing.
Chapter 2 The Two-Dimensional Bin Packing Problem
5
6
3
1
13
3
4
2
1
1
2
4
(a) NFDH
3
5
4
2
6
(b) FFDH
5
6
(c) BFDH
Figure 2.2: Three classical strategies for the level packing.
Coffman, Garey, Johnson and Tarjan [17] analyzed NFDH and FFDH and determined
their asymptotic worst-case behavior. They proved that, if the heights are normalized
so that maxj {hj } = 1, then
N F DH(I) ≤ 2 · OP T (I) + 1
(2.20)
17
· OP T (I) + 1
10
(2.21)
and
F F DH(I) ≤
Both bounds are tight (meaning that the multiplicative constants are as small as possible) and, if the hj ’s are not normalized, only the additive term is affected. Observe the
similarity of (2.20) and (2.21) with famous results on the one-dimensional counterparts
of NFDH and FFDH (algorithms Next-Fit and First-Fit, respectively, see Johnson, Demers, Ullman, Garey and Graham [41]).
Any algorithm requiring item sorting is obviously Ω(n log n). Both NFDH and FFDH
can be implemented so as to require O(n log n) time, by using the appropriate data
structures adopted for the one-dimensional case (see Johnson [40]).
In addition we briefly explain other well-known algorithms for strip packing.
• Split Fit (SF) algorithm [17]: heights and widths of all items to be packed are
scaled so that the strip has unit width. The largest integer m ≥ 1 is then
determined for which all items in J have width less than or equal to 1/m. The
list is divided into two sub-lists Lwide and Lnarrow , both ordered according to nonincreasing height such that Lwide contains all items whose widths are greater than
1/(m+1) and Lnarrow contains all items whose widths are at most 1/(m+1). The
items in the list Lwide are packed using the FFDH algorithm and all the items
placed on a particular level are referred to collectively as a block. The blocks
of this packing are then rearranged such that blocks of total width greater than
14
Chapter 2 The Two-Dimensional Bin Packing Problem
(m+1)/(m+2) are at the bottom of the packing, followed by blocks of total width
at most (m+1)/(m+2). This process of shifting the blocks creates a rectangular
region R of width 1/(m+2) to the right of the latter blocks. The items in Lnarrow
are then packed, again using the FFDH algorithm, with the packing starting in
the region R. If an item does not fit into R, then the packing continues above the
packing of Lwide . It is proved that SF (I) ≤ (3/2) · OP T (I) + 2; the asymptotic
bound of 3/2 is tight.
• Reverse-fit (RF) algorithm [67]: it normalizes the width of the strip and the items
so that the strip is of unit width. RF first stacks all items of width greater than
1/2. Remaining items are sorted in non-increasing height and are packed above
the height H0 reached by those greater than 1/2. Then RF repeats the following
process. It packs items from left to right with their bottom along the line of
height H0 until there is no more space. Then packs items from right to left and
from top to bottom (called reverse-level) until the total width is at least 1/2.
Then the reverse-level is dropped down until, at least, one of them touches some
item below. The drop down is repeated. It is proved that RF (I) ≤ 2 · OP T (I).
• Steinberg’s algorithm [70]: it estimates an upper bound of the height H required
to pack all the items such that it is proved that the input items can be packed
into a rectangle of width W and height H. It then defines seven procedures with
seven conditions, each to divide a problem into two smaller ones and solves them
recursively. It has been showed that any tractable problem satisfies one of the
seven conditions. It is proved that Steinberg’s algorithm(I) ≤ 2 · OP T (I)
• Sleator’s algorithm [68]: it normalizes the width of the strip and the items so that
the strip is of unit width. it consists of four steps: (1) all items of width greater
than 1/2 are packed on top of one another in the bottom of the strip. Suppose
h0 is the height of the resulting packing all subsequent packing will occur above
h0 . (2) Remaining items are ordered by non-increasing height. A level of items
are packed (in non-increasing height order) from left to right along the line of
height h0 . (3) A vertical line is then drawn in the middle to cut the strip into two
equal halves (note this line may cut an item that is packed partially in the right
half). Two horizontal line segments are drawn of length one half, one across the
left half (called the left baseline) and one across the right half (called the right
baseline) as low as possible such that the two lines do not cross any item. (4)
The left or right baseline which is of a lower height is choosen and a level of items
into the corresponding half of the strip is packed until the next item is too wide.
A new baseline is formed and Step (4) is repeated on the lower baseline until all
items are packed. It is proved that Sleator’s algorithm has an asymptotic tight
bound equal to 5/2.
• Bottom-Left (BL) algorithm: it sorts the items by non-increasing width, and
packs the the current item in the lowest possible position, left justified.
Chapter 2 The Two-Dimensional Bin Packing Problem
15
Baker, Coffman and Rivest [1] analyzed the worst-case performance of the BL
algorithm and proved that: (i) if no item ordering is used, BL may be arbitrarily
bad; (ii) if the items are ordered by non-increasing width then BL(I) ≤ 3 ·
OP T (I), and the bound is tight.
2.7.2
Bin packing: Two-phase heuristics
A two-phase algorithm for the finite bin packing problem, called Hybrid First-Fit
(HFF), was proposed by Chung, Garey and Johnson [16]. In the first phase, a strip
packing is obtained through the FFDH strategy. Let H1 , H2 , . . . be the heights of the
resulting levels, and observe that H1 ≥ H2 ≥ . . . . A finite bin packing solution is then
obtained by heuristically solving a one-dimensional bin packing problem (with item
sizes Hi and bin capacity H) through the First-Fit Decreasing algorithm: initialize bin
1 to pack level 1, and, for increasing i = 2, . . . , pack the current level i into the lowest
indexed bin where it fits, if any; if no bin can accommodate i, initialize a new bin. An
example is shown in Figure 2.3. Chung, Garey and Johnson [16] proved that, if the
heights are normalized to one, then
HF F (I) ≤
17
· OP T (I) + 5
8
(2.22)
The bound is not proved to be tight: the worst example gives HF F (I) =
1). Both phases can be implemented so as to require O(n log n) time.
91
45 ·(OP T (I)−
5
4
7
2
6
1
4
7
5
1
3
3
2
6
(a) HFF: phase 1
(b) HFF: phase 2 bin no.1 (c) HFF: phase 2 bin no.2
Figure 2.3: Algorithm HFF.
Berkey and Wang [5] proposed and experimentally evaluated a two-phase algorithm,
called Finite Best-Strip (FBS), which is a variation of HFF. The first phase is performed
by using the BFDH strategy. In the second phase, the one-dimensional bin packing
problem is solved through the Best-Fit Decreasing algorithm: pack the current level
16
Chapter 2 The Two-Dimensional Bin Packing Problem
in that bin, among those where it fits (if any), for which the unused vertical space is
a minimum, or by initializing a new bin. An example is shown in Figure 2.4. (For
the sake of uniformity, Hybrid Best-Fit would be a more appropriate name for this
algorithm.)
5
6
4
7
2
4
7
1
5
1
3
(a) FBS: phase 1
2
3
(b) FBS: phase 2 bin no.1
6
(c) FBS: phase 2 bin no.2
Figure 2.4: Algorithm FBS.
Let us consider now another variation of HFF, in which the NFDH strategy is adopted
in the first phase, and the one-dimensional bin packing problem is solved through the
Next-Fit Decreasing algorithm: pack the current level in the current bin if it fits, or
initialize a new (current) bin otherwise. Due to the next-fit policy, this algorithm is
equivalent to a one-phase algorithm in which the current item is packed on the current
level of the current bin, if possible; otherwise, a new (current) level is initialized either
in the current bin (if enough vertical space is available), or in a new (current) bin.
Frenk and Galambos [28] analyzed the resulting algorithm, Hybrid Next-Fit (HNF), by
characterizing its asymptotic worst-case performance as a function of maxj {wj } and
maxj {hj }. By assuming that the heights and widths are normalized to one, the worst
performance occurs for maxj {wj } > 21 and maxj {hj } ≥ 12 , and gives:
HN F (I) ≤ 3.382 · · · · OP T (I) + 9
(2.23)
where 3.382 . . . is an approximation for a tight but irrational bound. The three algorithms above can be implemented so as to require O(n log n) time.
The next two algorithms have higher worst-case time complexities, although they are,
in practice, very fast and effective.
Lodi, Martello and Vigo [54, 53] presented an approach (Floor-Ceiling, FC) which
extends the way items are packed on the levels. Denote the horizontal line defined
by the top (resp. bottom) edge of the tallest item packed on a level as the ceiling
Chapter 2 The Two-Dimensional Bin Packing Problem
8
1
2
3
17
ceiling
6
5
4
7
floor
Figure 2.5: Algorithm FC.
(resp. floor) of the level. The previous algorithms pack the items, from left to right,
with their bottom edge on the level floor. Algorithm FC may, in addition, pack them,
from right to left, with their top edge on the level ceiling. The first item packed on a
ceiling can only be one which cannot be packed on the floor below. A possible floorceiling packing is shown in Figure 2.5. In the first phase, the current item is packed, in
order of preference: (i) on a ceiling (provided that the requirement above is satisfied),
according to a best-fit strategy; (ii) on a floor, according to a best-fit strategy; (iii)
on the floor of a new level. In the second phase, the levels are packed into finite bins,
either through the Best-Fit Decreasing algorithm or by using an exact algorithm for
the one-dimensional bin packing problem, halted after a prefixed number of iterations.
The implementation of the first phase given in [54] requires O(n3 ) time, while the
complexity of the second one obviously depends on the selected algorithm.
Another level packing strategy based on the exact solution of induced subproblems is
adopted in the Knapsack Packing (KP) algorithm proposed by Lodi, Martello and Vigo
[53]. The first phase of the algorithm packs one level at a time as follows. The first
(tallest) unpacked item, say j ∗ , initializes the level, which is then completed by solving
an associated knapsack problem instance over all the unpacked items, where: (i) the
knapsack capacity is W − wj ∗ ; (ii) the weight of an item j is wj ; (iii) the profit of an
item j is its area wj hj . Finite bins are finally obtained as in algorithm FC. Algorithm
KP (as well as algorithm FC above) may require the solution of NP-hard subproblems,
producing a non-polynomial time complexity. In practice, however, the execution of
the codes for the NP-hard problems is always halted after a prefixed (small) number
of iterations, and in almost all cases, the optimal solution is obtained before the limit
is reached (see the computational experiments in [53]).
2.7.3
Bin packing: One-phase level heuristics
Two one-phase algorithms were presented and experimentally evaluated by Berkey and
Wang [5].
18
Chapter 2 The Two-Dimensional Bin Packing Problem
Algorithm Finite Next-Fit (FNF) directly packs the items into finite bins exactly in
the way algorithm HNF of the previous section does. (Papers [5] and [28] appeared in
the same year.) An example is shown in Figure 2.6.
3
4
7
1
2
5
(b) FNF: bin no.2
(a) FNF: bin no.1
6
(c) FNF: bin no.3
Figure 2.6: Algorithm FNF.
Algorithm Finite First-Fit (FFF) adopts instead the FFDH strategy. The current item
is packed on the lowest level of the first bin where it fits; if no level can accommodate
it, a new level is created either in the first suitable bin, or by initializing a new bin (if
no bin has enough vertical space available). An example is shown in Figure 2.7.
4
6
7
1
3
(a) FFF: bin no.1
5
2
(b) FFF: bin no.2
Figure 2.7: Algorithm FFF.
Both algorithms can be implemented so as to require O(n log n) time.
2.7.4
Bin packing: One-phase non-level heuristics
We finally consider algorithms which do not pack the items by levels. All the algorithms
discussed in the following are one-phase.
The main non-level strategy is known as Bottom-Left (BL), and consists in packing
the current item in the lowest possible position, left justified.
Berkey and Wang [5] proposed the BL approach for the finite bin case. Their Finite
Bottom-Left (FBL) algorithm initially sorts the items by non-increasing width. The
current item is then packed in the lowest position of any initialized bin, left justified;
if no bin can allocate it, a new one is initialized. An example is shown in Figure 2.8.
Chapter 2 The Two-Dimensional Bin Packing Problem
19
The computer implementation of algorithm BL was studied by Chazelle [14], who gave
a method for producing a packing in O(n2 ) time. The same approach was adopted by
Berkey and Wang [5].
7
2
4
1
3
5
6
(a) FBL: bin no.1
(b) FBL: bin no.2
Figure 2.8: Algorithm FBL.
Berkey and Wang [5] also proposed the Next Bottom-left (NBL) algorithm which is
similar to FBL but, in this case, the generation of a new bin for packing mean that all
the free spaces from the previous bin are discarded. Thus only one bin is active at a
time. An example is shown in Figure 2.9.
7
2
4
6
1
3
5
(a) NBL: bin no.1
(b) NBL: bin no.2
Figure 2.9: Algorithm NBL.
Lodi, Martello and Vigo [53] proposed a different non-level approach, called Alternate
Directions (AD). The method is illustrated in Figure 2.10. The algorithm initializes L
bins (L being a lower bound on the optimal solution value, see Section 2.8) by packing
on their bottoms a subset of the items, following a best-fit decreasing policy (items 1,
2, 3, 7 and 9 in Figure 2.10, where it is assumed that L = 2). The remaining items are
packed, one bin at a time, into bands, alternatively from left to right and from right
to left. As soon as no item can be packed in either direction in the current bin, the
next initialized bin or a new empty bin (the third one in Figure 2.10, when item 11 is
considered) becomes the current one. The algorithm has O(n3 ) time complexity.
2.7.5
Metaheuristics
Heuristic approaches are particularly useful for problems with a high complexity, for
which deterministic methods like the branch and bound approach are often unable to
20
Chapter 2 The Two-Dimensional Bin Packing Problem
10
8
4
6
5
1
12
2
7
3
9
11
Figure 2.10: Algorithm AD.
find the solution within a reasonable amount of time. Although heuristics are fast in
generating a solution packing plan, the quality of the solution is highly dependent on
the input sequence of items.
Meta-heuristic approaches are frequently used for the approximate solution of hard
combinatorial optimization problems. Meta-heuristics such as evolutionary algorithms
(genetic algorithms are the most popular type), simulated annealing and tabu search
which are probabilistic in nature have also been applied to solve bin packing problems.
Before presenting specific algorithms we briefly recall the main meta-heuristic techniques.
Genetic algorithm (GA)
One of the optimization and global search methods is based on Darwin’s theory of
evolution and simulated natural selection (see Goldberg [33]). GA was developed further by Holland in the 1970s. It is applied effectively to solve various combinatorial
optimization problems and worked with probabilistic rules (see Holland [38]).
GA searches new and better solutions to a problem by improving current population.
This is obtained by extracting the most desirable characteristics from a generation and
combining them to form the next generation. The population comprises a set of chromosomes. Each chromosome in the population is a possible solution and the quality
of each possible solution is measured by fitness function.
First, GA generates initial population and then calculates the fitness value with fitness function for each chromosome of the population. Fitness function is specifically
generated for each problem. Then optimization criterion is checked. If optimization
criteria are met, this solution can be considered as the best solution. Otherwise, new
population is regenerated using GA operators (selection, crossover, and mutation).
• Selection: it selects a proportion of the existing population to breed a new generation. Individual chromosomes are selected through a fitness-based process, where
fitter chromosomes (as measured by the fitness function) are typically more likely
to be selected.
Chapter 2 The Two-Dimensional Bin Packing Problem
21
• Crossover: it exchanges information between chromosomes and creates new solutions.
• Mutation: it is used to prevent reproduction of similar type chromosomes in
population.
The process is to continue through number of generations until convergence on optimal
or near-optimal solutions.
Simulated Annealing (SA)
SA firstly developed by Kirkpatrick (see [44]) is based on the analogy between the
process of finding a possible best solution of a combinatorial optimization problem and
the annealing process of a solid to its minimum energy state in statistical physics.
The searching process starts with one initial random solution. A neighborhood of this
solution is generated using any neighborhood move rule and then the cost between
neighborhood solution and current solution can be found with 2.24.
∆C = Ci − Ci−1
(2.24)
where ∆C represents change amount between costs of the two solutions. Ci and Ci−1
represents neighborhood solution and current solution, respectively. If the cost decreases, the current solution is replaced by the generated neighborhood solution. Otherwise the current solution is replaced by the generated neighborhood solution by a
specific possibility calculated in 2.25 or a new neighborhood solution is regenerated and
steps are repeated until this step. After new solution is accepted, inner loop is checked.
If the inner loop criterion is met, the value of temperature is decreased using by predefined a cooling schedule. Otherwise a new neighborhood solution is regenerated and
steps are repeated until this step. The searching is repeated until the termination
criteria are met or no further improvement can be found in the neighborhood of the
current solution. The termination criterion (outer loop) is predetermined.
e−∆C/T > R
(2.25)
where T temperature is a positive control parameter. R is a uniform random number
between 0 and 1.
Tabu Search (TS)
Tabu search uses a local or neighborhood search procedure to iteratively move from one
potential solution x to an improved solution x0 in the neighborhood of x, until some
stopping criterion has been satisfied. Local search procedures often become stuck in
poor-scoring areas or areas where scores plateau. In order to avoid these pitfalls and
explore regions of the search space that would be left unexplored by other local search
22
Chapter 2 The Two-Dimensional Bin Packing Problem
procedures, tabu search carefully explores the neighborhood of each solution as the
search progresses. The solutions admitted to the new neighborhood, N ∗ (x), are determined through the use of memory structures. Using these memory structures, the
search progresses by iteratively moving from the current solution x to an improved
solution x0 in N ∗ (x).
These memory structures form what is known as the tabu list, a set of rules and banned
solutions used to filter which solutions will be admitted to the neighborhood N ∗ (x) to
be explored by the search. In its simplest form, a tabu list is a short-term set of the
solutions that have been visited in the recent past.
Lodi, Martello and Vigo [54, 52, 53] developed effective tabu search (TS) algorithms
for 2BP and for variants of the problem involving the possibility of rotating the items
by 90◦ or the additional constraint that the items may be obtained from the resulting patterns through guillotine cuts. We briefly describe here the unified tabu search
framework given in [53], whose main characteristic is the adoption of a search scheme
and a neighborhood which are independent of the specific packing problem to be solved.
The framework can thus be used for virtually any variant of 2BP, by simply changing
the specific deterministic algorithm used for evaluating the moves within the neighborhood search.
Given a current solution, the moves modify it by changing the packing of a subset S
of items, trying to empty a specified target bin selected among those that currently
pack a small area and a relatively large number of items. Subset S is defined so as to
include one item, j, from the target bin and the current contents of k other bins, and
the new packing is obtained by executing an appropriate heuristic algorithm on S. If
the move packs the items of S into k (or less) bins, i.e., item j has been removed from
the target bin, a new item is selected, a new set S is defined accordingly, and a new
move is performed. Otherwise S is changed by selecting a different set of k bins, or a
different item j from the target bin.
The above framework above was suitably combined with a genetic algorithm by Iori,
Martello and Monaci [39] so as to get a hybrid algorithm for 2SP that can be easily
adapted to other packing problems in two and more dimensions.
A different metaheuristic for 2BP has been proposed by Færø, Pisinger and Zachariasen
[22]. Their guided local search algorithm starts from a feasible solution, and randomly
removes some bins by assigning the corresponding items to the other bins. The new
solution is generally infeasible, leading to an optimization problem in which one is
required to minimize an objective function that measures the pairwise overlapping
area. The associated neighborhood is explored through object shifts, until a feasible
solution is found.
Boschetti and Mingozzi [7, 8] proposed new lower bounds and an effective randomized
multi-start heuristic for 2BP which:
Chapter 2 The Two-Dimensional Bin Packing Problem
23
(i) assigns a score to each item;
(ii) packs the items, one at a time, according to decreasing values of the corresponding
scores;
(iii) updates the scores by using a specified criterion, and
(iv) iterates on (ii) and (iii) until an optimal solution is found or a maximum number
of iterations has been performed.
The execution of the algorithm is repeated for a given set of different criteria used for
the updating of the object scores.
Monaci and Toth [62] proposed a 2-phase heuristic algorithm based on formulation
(2.8)–(2.10). In the first phase (column generation), a large set of different feasible
patterns is produced by using heuristic algorithms from the literature, while in the
second phase (column optimization) a subset of patterns is selected by heuristically
solving the associated set covering instance.
Sokea and Bingul [69] propesed hybrid genetic algorithm and simulated annealing for
two-dimensional non-guillotine rectangular packing problems. In their paper, GA and
SA were used separately to obtain permutation for placing the small pieces. Improved
BL algorithm was employed to place rectangular pieces. The solution approach in their
study can be summarized below:
• GA and SA were used to find permutations with small trim loss.
• An improved BL algorithm was used to place rectangular pieces corresponding
to a particular permutation.
These solution approaches, where GA and SA are combined with improved BL algorithm, are known as hybrid GA and hybrid SA.
The current literature on the bin packing problem mostly focuses on the minimization
of wasted space. However in most bin packing problems, both minimization of wasted
space and balance of the bins needs to be achieved. Liu, Tan, Huang, Goh, Ho [48]
formulated a multiobjective two-dimensional bin packing model (MOBPP-2D), with
minimum wasted space and balancing of load as two objectives.
2.7.6
Approximation algorithms
The long standing question on the approximability of 2BP and 2SP found an answer
in recent years. A fully polynomial-time approximation scheme for 2SP was developed
by Kenyon and Rémila [43], which easily produces a 2 + ε guarantee for 2BP.
24
Chapter 2 The Two-Dimensional Bin Packing Problem
Caprara, Lodi and Monaci [10] gave an Asymptotic Fully Polynomial Time Approximation Scheme (AFPTAS) for 2BP with level restriction. Later, Caprara [9] proposed
an algorithm for the general 2BP with T∞ + ε asymptotic worst-case guarantee, where
T∞ = 1.691 . . . is the well-known guarantee of the harmonic algorithm for 1BP (see Lee
and Lee [46]). This result was further improved by Bansal, Caprara and Sviridenko [2],
who presented a general framework to improve previous approximation algorithms and
obtained asymptotic approximation guarantees arbitrarily close to 1.525. . . for packing
with or without rotations. This is currently the best known asymptotic result. Finally,
concerning inapproximability, Bansal and Sviridenko [3] proved that no APTAS may
exist for 2BP (see also Bansal, Correa, Kenyon and Sviridenko [63]).
All previous results concern asymptotic approximability, i.e., the approximation ratio
gets only close to the stated values for instances involving a very large number of
items. As to the absolute approximation ratio, we mention the paper by Zhang [74], in
which a 3-approximation algorithm for 2BP is given. A 2-approximation algorithm was
obtained by van Stee [72] for the special case where items and bins are squares, and
by Harren and van Stee [37] for the case in which rotation by 90◦ is allowed. Finally,
Harren and van Stee [36] improved their previous results by deriving an approximation
algorithm for 2BP having an absolute approximation ratio equal to 2. This is the best
possible polynomial time approximation for this problem, unless P = N P
2.8.
Lower Bounds
Good lower bounds on the optimal solution value are important both in the implementation of exact enumerative approaches and in the empirical evaluation of approximate
solutions. The simplest bound for 2BP is the Area Bound
& Pn
L0 =
j=1 wj hj
'
WH
computable in linear time. Martello and Vigo [61] determined the absolute worst-case
behavior of L0 :
1
L0 (I) ≥ · OP T (I)
4
where L0 (I) and OP T (I) denote the value produced by L0 and the optimal solution
value, respectively, for an instance I of problem P . The bound is tight, as shown by
the example in Figure 2.11. The result holds even if rotation of the items (by any
angle) is allowed.
A better lower bound can be obtained, in non-polynomial time, by solving the one
dimensional bin packing instance defined by element sizes wj hj (j = 1, . . . , n) and
capacity W H. Caprara and Monaci [11] showed that the optimal solution of such 1BP
Chapter 2 The Two-Dimensional Bin Packing Problem
25
H
2
W
2
Figure 2.11: Worst-case of the area bound.
instance yields a valid lower bound for 2BP, say L1 such that L1 (I) ≥
each instance I of 2BP.
1
3
· OP T (I) for
In many cases, the approximation provided by both bounds can be weak, or the required computing time can be too large for an effective use within an exact algorithm.
A tighter bound was proposed by Martello and Vigo [61]. Given any integer value q,
1 ≤ q ≤ 21 W , let
K1 = {j ∈ J : wj > W − q}
(2.26)
1
K2 = {j ∈ J : W − q ≥ wj > W }
2
1
K3 = {j ∈ J : W ≥ wj ≥ q}
2
(2.27)
(2.28)
and observe that no two items of K1 ∪ K2 may be packed side by side into a bin.
Hence, a lower bound LW
1 for the sub-instance given by the items in K1 ∪ K2 can be
obtained by using any lower bound for the 1BP instance defined by element sizes hj
(j ∈ K1 ∪ K2 ) and capacity H (see Martello and Toth [71], Dell’Amico and Martello
[20]). A lower bound for the complete instance is then obtained by taking into account
the items in K3 , since none of them may be packed besides an item of K1 :
( &P
LW
2 (q)
=
LW
1
+ max 0,
j∈K2 ∪K3
wj hj − (HLW
1 −
P
j∈K1
hj )W
WH
')
(2.29)
A symmetric bound LH
2 (q) is clearly obtained by interchanging widths and heights.
By observing that both bounds are valid for any q, we have an overall lower bound:
!
L2 = max
max
1≤q≤ 12 W
{LW
2 (q)}
,
max
1≤q≤ 21 H
{LH
2 (q)}
(2.30)
It is shown in [61] that, for any instance of 2BP, the value produced by L2 is no less
than that produced by L0 , and that L2 can be computed in O(n2 ) time.
26
Chapter 2 The Two-Dimensional Bin Packing Problem
Martello and Vigo [61] also proposed a computationally more expensive lower bound,
which in some cases improves on L2 . Given any pair of integers (p, q), with 1 ≤ p ≤ 21 H
and 1 ≤ q ≤ 12 W , define:
I1 = {j ∈ J : hj > H − p and wj > W − q}
(2.31)
I2 = {j ∈ J \ I1 : hj > 12 H and wj > 12 W }
(2.32)
I3 = {j ∈ J : 21 H ≥ hj ≥ p and 21 W ≥ wj ≥ q}
(2.33)
(see Figure 2.12 (a)), and observe that: (i) I1 ∪ I2 is independent of (p, q); (ii) no
two items of I1 ∪ I2 may be packed into the same bin; (iii) no item of I3 fits into a
bin containing an item of I1 . A valid lower bound can thus be computed by adding
to |I1 ∪ I2 | the minimum number of bins needed for those items of I3 that cannot
be packed into the bins used for the items of I2 . Such a bound can be determined
by considering a relaxed instance where each item i ∈ I3 has the minimum size, i.e.,
hi = p and wi = q. Given a bin containing an item j, the maximum number of p × q
items that can be packed into the bin is (see Figure 2.12 (b)):
H
m(j, p, q) =
p
W − wj
q
W
+
q
H − hj
p
H − hj
−
p
W − wj
q
(2.34)
item of I1
items of I2
item of I3
6
H
H −p
1
2H
p
1
2W
q
W −q
W
(a)
j
(b)
Figure 2.12: (a) items in I1 , I2 and I3 ; (b) relaxed instance with reduced items.
Chapter 2 The Two-Dimensional Bin Packing Problem
27
Hence, for any pair (p, q) a valid lower bound is
 

P

|I3 | − j∈I2 m(j, p, q) 

j kj k
L3 (p, q) = |I1 ∪ I2 | + max 0, 

H
W
 


p
q
(2.35)
so an overall bound is
L3 =
max
1
1
1≤p≤ 2 H, 1≤q≤ 2 W
{L3 (p, q)}
(2.36)
Lower bound L3 can be computed in O(n3 ) time. No dominance relation exists between
L2 and L3 .
The bounds above were further improved by Boschetti and Mingozzi [7, 8], who also
proposed some lower bounds for the 2BP variant in which items can be rotated by 90◦ .
Fekete and Schepers [23, 25] proposed a general bounding technique for bin and strip
packing problems in one or more dimensions, based on dual feasible functions. A
function u : [0, 1] → [0, 1] is called dual feasible (see Lueker [59]) if for any finite set S
of nonnegative real numbers, we have the relation
X
x≤1⇒
x∈S
X
u(x) ≤ 1
(2.37)
x∈S
Consider any 1BP instance, and normalize it by setting hj = hj /H (j = 1, . . . , n) and
H = 1. For any dual feasible function u, any lower bound for the transformed instance
having item sizes u(h1 ), . . . , u(hn ) is then a valid lower bound for the original instance.
In [23] Fekete and Schepers introduced a class of dual feasible functions for 1BP, while
in [25] they extended the approach to the packing in two or more dimensions. For a
d-dimensional bin packing problem, a set of d dual feasible functions {u1 , . . . , ud } is
called a conservative scale. Thus, given any conservative scale C = {u1 , u2 }, a valid
lower bound for 2BP is given by
L(C) =
n
X
u1 (wj )u2 (hj )
(2.38)
j=1
where the hj and wj values are assumed to be normalized as shown above. Given a
set V of conservative scales, a valid lower bound is
Lb = max L(C)
C∈V
(2.39)
The approach by Fekete and Schepers was further investigated by Caprara and Monaci
[12]. The basic idea is that any pair of dual feasible functions, associated with item
widths and heights, respectively, leads to a valid lower bound for a given 2BP instance.
The problem of determining the pair of dual feasible functions leading to the best
28
Chapter 2 The Two-Dimensional Bin Packing Problem
(highest) lower bound was formulated as a disjoint bilinear program. Computational
experiments in [12] showed that for most instances of the literature the resulting lower
bound value is equal to that obtained by the continuous relaxation of the set covering
formulation (2.8)-(2.10), while requiring computing times that are orders of magnitude
smaller.
2.9.
Exact Algorithms
An enumerative approach for the exact solution of 2BP was presented by Martello
and Vigo [61]. The items are initially sorted in non-increasing order of their area. A
reduction procedure tries to determine the optimal packing of some bins, thus reducing
the size of the instance. A first incumbent solution, of value z ∗ , is then heuristically
obtained.
The algorithm is based on a two-level branching scheme:
• outer branch-decision tree: at each decision node, an item is assigned to a bin
without specifying its actual position;
• inner branch-decision tree: a feasible packing (if any) for the items currently
assigned to a bin is determined, possibly through enumeration of all the possible
patterns.
The outer branch-decision tree is searched in a depth-first way, making use of the lower
bounds described in the previous section. Whenever it is possible to establish that no
more unassigned items can be assigned to a given initialized bin, such a bin is closed:
an initialized and not closed bin is called active. At level k (k = 1, . . . , n), item k is
assigned, in turn, to all the active bins and, possibly, to a new one (if the total number
of active and closed bins is less than z ∗ − 1).
The feasibility of the assignment of an item to a bin is first heuristically checked. A
lower bound L(I) is computed for the instance I defined by the items currently assigned
to the bin: if L(I) > 1, a backtracking follows. Otherwise, heuristic algorithms are
applied to I: if a feasible single-bin packing is found, the outer enumeration is resumed.
If not, the inner branching scheme enumerates all the possible ways to pack I into a
bin through the left-most downward strategy (see Hadjiconstantinou and Christofides
[15]): at each level, the next item is placed, in turn, into all positions where it has its
left edge adjacent either to the right edge of another item or to the left edge of the bin,
and its bottom edge adjacent either to the top edge of another item or to the bottom
edge of the bin. As soon as a feasible packing is found for all the items of I, the outer
enumeration is resumed. If no such packing exists, an outer backtracking is performed.
Chapter 2 The Two-Dimensional Bin Packing Problem
29
Whenever the current assignment is feasible, the possibility of closing the bin is checked
through lower bound computations.
Martello, Monaci and Vigo [60] presented a branch-and-bound algorithm for the twodimensional strip packing problem, in which lower bounds are computed through a
relaxation that replaces each wj × hj item with hj unit-height one dimensional items
of width wj , thus inducing an instance of 1BP.
Fekete, Schepers and van der Veen [26] developed an enumerative approach to the exact
solution of the problem of packing a set of items into a single bin. Such approach is
based on the model presented in [24] and discussed in Section 2.5, and could be used
for alternative exact approaches to 2BP and 2SP. Specifically,
(i) for 2BP, it could be used in place of the inner decision-tree of the two-level
approach above;
(ii) for 2SP, one could determine, through binary search, the minimum height H such
that all the items can be packed into a single bin of base W and height H.
More recently, Pisinger and Sigurd [64] implemented a branch-and-price algorithm for
the exact solution of (2.8)–(2.10). As mentioned in Section 2.5, the slave problem in
column generation requires to determine a suitable set of items to be packed into a
single bin. This is solved in [64] as a constraint-satisfaction problem, using forward
propagation to prune dominated arrangements of rectangles.
Chapter 3
Two-Dimensional Bin Packing:
the 2BP|O|G case
3.1.
Introduction
In 1 the following we consider the problem of packing a set J of 2-dimensional items
into the minimum number of identical 2-dimensional bins. We will denote by wj and
hj the width and the height, respectively, of each item j ∈ J. Similarly, we will denote
by W and H the width and the height of each bin. Without loss of generality, we will
assume in the following that W = H = 1. We require that the items must be packed,
without overlapping, with their edges parallel to the edges of the bin, and cannot be
rotated. The resulting problem, as mentioned before, is denoted as 2BP|O|F.
In addition, we will consider the variant of the problem in which each item should
be obtained by a sequence of edge-to-edge cuts, i.e., each bin should correspond to a
guillotinable pattern. This variant of the problem, denoted as 2BP|O|G, is motivated by
technological constraints in many real-world applications, where automatic machines
are used to cut items, but can lead to a lower usage of the bins.
1
This chapter is based on: A. Lodi, M. Monaci, E. Pietrobuoni, ”Two-Dimensional Bin Packing
Problem with Guillotine Constraints”. to be submitted for publication.
31
32
3.1.1
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
Our goals
The present chapter has three main contributions: the first one is
Problem P0: provide a (simple) mathematical characterization of non-guillotine patterns.
The solution of this problem is a classification of different patterns that correspond
to non-guillotinable solutions, and their description by means of some mathematical
tools. Given that, we consider two relevant problems concerning the relation between
the solutions of 2BP|O|G with respect to the 2BP|O|F counterparts, namely
Problem P1: Given a non-guillotine pattern P that packs a given set of items into a unique
bin, determine the minimum area M A(P ) of the items that one has to remove
in order to produce a guillotinable pattern. Formally,
M A(P ) = sup min{
X
wj hj : P \ S is guillotinable}
(3.1)
j∈S
Problem P2: Given an instance N of the two problems (i.e., a set of items), let opt2BP|O|F (N )
and opt2BP|O|G (N ) denote, respectively, the optimal solution values of problems
2BP|O|F and 2BP|O|G for item set N . Determine the value of the asymptotic
Price of Guillotinability defined as
(
P oG = lim sup
z→∞
opt2BP|O|G (N )
: opt2BP|O|F (N ) ≥ z
opt2BP|O|F (N )
)
.
(3.2)
Indeed, only a marginal deterioration of the 2BP|O|G solutions with respect to the
2BP|O|F counterparts, is experienced from an experimental point of view (see [57]).
In the present paper we provide a missing yet very important piece of information
and evaluate, from a worst-case perspective, the solution worsening when guillotine
constraints are imposed.
To be more precise, we will concentrate on a special case in which all items in pattern
P are fixed, i.e., they cannot be moved from the position they have in a given 2BP|O|F
pattern. Even in this overconstrained settings, we are able to compute a tight value
for the optimal solutions of P1 and P2 in a relevant special case, and we are able to
provide a tight value for P1 and a quite tight lower and upper bounds for P2 in another
special case.
In the next section we give some definitions that will be used throughout the paper.
During our analysis we will consider one bin at a time. In Section 3.1.3 we present
an algorithm that we assume to be applied to the set of items that are packed in the
current bin. After this operation is carried out, a removal algorithm will be applied in
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
33
order to enforce guillotinability; this is described in the Packing Algorithm of Section
3.1.4. Then we characterize the smallest non-separable pattern in Section 3.2 and the
Blocked Ring in Section 3.3. This will lead to a complete characterization of nonguillotinable patterns, as described in Section 3.4, and to an analysis of problems P1
and P2 in Section 3.5.
3.1.2
Definitions
Recall that we consider one bin at a time. Let P denote the set of items that are
packed in the current bin. In addition, let xj and yj be the coordinates at which the
bottom-left corner of each item j is packed. With an abuse of notation, we will use P
to denote also the packing pattern for the bin.
Definition 1. (Guillotine cut) A guillotine cut for a pattern P is an edge-to-edge
cut that intersects no item in P .
A guillotine cut can be either horizontal or vertical, depending on its orientation; see,
e.g., the horizontal line AB and the vertical line CD in Figure 3.1. Each guillotine
cut that does not coincide with one side of the bin divides a given pattern into two
induced sub-patterns. We will concentrate on proper guillotine cuts only, i.e., guillotine
cuts such that both sub-patterns include at least one item. Intuitively, we disregard
guillotine cuts like line AB in Figure 3.1, that do no separate any item from other
items.
D
1
2
4
3
A
B
C
Figure 3.1: Example of guillotine pattern.
Definition 2. (Separable pattern) A pattern P is said separable if there exists a
proper guillotine cut for P .
A pattern P that contains no proper guillotine cut is said non-separable. A nonseparable pattern P is said minimal if removing any item u ∈ P yields a separable
pattern.
34
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
Definition 3. (Guillotinable pattern) A pattern P is said guillotinable P if all
induced sub-patterns P 0 with |P 0 | ≥ 2 are separable.
3.1.3
Convexification Algorithm
We first introduce the following Convexification Algorithm that can be applied to any
pattern P . The algorithm is illustrated in Figure 3.2 and is composed of 3 major steps:
each item is assigned a label (step 1), and items are considered according to this order,
extending the current item until it touches some other item (step 2, see Figure 3.3).
Then, pairs of items that can be joined into a larger rectangular item (if any) are
merged (steps 3 and 4, see Figure 3.4). Finally, step 5 partitions each free area in the
bin (if any) into some dummy items (see Figure 3.5).
Convexification Algorithm:
1. assign a label to each item;
2. extend each item horizontally and vertically until it touches some other item;
repeat
3.
merge pair of items that touch vertically, have the same height and are
placed at the same y-coordinate;
4.
merge pair of items that touch horizontally, have the same width and are
placed at the same x-coordinate;
until no more merge is possible;
5. possibly define one or more dummy items for each remaining free space in the
pattern.
Figure 3.2: The convexification algorithm.
2
2
3
3
1
4
4
1
5
5
Figure 3.3: Convexification algorithm: step 2.
After the execution of the algorithm on a given pattern P , one can define a new pattern
P such that the total area in P equals the area of the bin. Note that each item u ∈ P is
associated with an item u ∈ P , while each u ∈ P may have been originated by joining
different items from P .
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
2
35
2
3
3
4
1
1
4
5
Figure 3.4: Convexification algorithm: step 3.
2
2
3
3
5
1
1
4
4
Figure 3.5: Convexification algorithm: step 5.
The following theorem states that the Convexification Algorithm cannot produce a
separable pattern P if the original pattern P is not separable.
Theorem 4. Let P be a non-separable pattern and P be the pattern produced by the
execution of the Convexification Algorithm on P . Then, P is non-separable.
Proof. Denote by (wu , hu ) and (xu , yu ) the dimensions and packing coordinates for
each item u ∈ P , respectively. Similarly, let (wu , hu ), and (xu , y u ) represent the same
figures for each item u ∈ P .
Consider an item u ∈ P and let u be any item in P originating u. Since the Convexification Algorithm cannot reduce the sizes of the items, we have
xu ≤ xu ,
xu + wu ≤ xu + wu ,
y u ≤ yu ,
yu + hu ≤ y u + hu
(3.3)
By contraddiction, assume pattern P is separable, i.e., there exist two items, say u and
v that can be separated by a guillotine cut. Without loss of generality assume this cut
is horizontal at a height y, and that item u is packed below item v, i.e.,
y u + hu ≤ y
and y ≤ y v
(3.4)
36
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
Denote by u (resp. v) any of the items in P that originated u (resp. v). By (3.3) the
horizontal cut y separates u and v also in the original pattern P ; however, as P is not
separable, this cut intersects some other item k, i.e., ∃k ∈ J such that
yk < y < yk + hk
(3.5)
Denoting by k ∈ P the item associated to k, and combining (3.3) and (3.5) we have
y k < y < y k + hk
which means that horizontal cut y intersects item k. Thus, pattern P is non-separable.
Note that the application of the Convexification Algorithm on a separable pattern P
may produce a pattern P that is non-separable; see, e.g., the example depicted in
Figure 3.6.
1
1
2
2
3
4
4
3
Figure 3.6: Convexification Algorithm on a separable pattern that produces a nonseparable pattern.
Property 1. The execution of the Convexification Algorithm on pattern P doesn’t
introduce non-guillotinability if rows of P are non-separable. See Definition 10.
Theorem 5. Let P be a pattern produced by the Convexification Algorithm. Then
either |P | = 1 or |P | ≥ 5.
Proof. Observe that the Convexification Algorithm produces a pattern P that entirely
fills the bin. It is clear that if P includes two items, then these items will be merged
into a unique item (see steps 3 and 4 of the algorithm). Similarly, all patterns with 3
items can be iteratively reduced to a single item: Figures 3.7 and 3.8 show all possible
patterns with 3 and 4 items, respectievly, without taking into account possible rotations
of the patterns by 90◦ .
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
37
2
1
2
3
1
3
Figure 3.7: Patterns with 3 items.
1
2
3
4
1
3
2
3
4
1
4
2
Figure 3.8: Patterns with 4 items.
Corollary 6. Let P be a non-separable pattern produced by the Convexification Algorithm. Then |P | ≥ 5.
3.1.4
Algorithm and assumptions
Our algorithm takes in input a feasible solution for 2BP|O|F and defines a feasible
solution for 2BP|O|G, considering one bin at a time. For each such bin pattern, the
algorithm executes the Convexification Algorithm of Section 3.1.3, thus producing a
new pattern (say) P . Then, the inner Packing Algorithm, described in Figure 3.9, is
executed to produce a separable pattern. This is either the original pattern P (in case
it contains only one item or is separable ), or is obtained by P by removing some items,
as described at Step 9.
Before describing the way we derive from P a separable pattern, we summarize some
assumptions.
1. Pattern P has been obtained using the Convexification Algorithm, as stated in
Step 1. of the algorithm.
2. The total area of the items in P is equal to the area of the bin, as the Convexification Algorithm may add some dummy items in Step 5 (see Figure 3.2)
3. Pattern P is non-separable, otherwise no action is required.
38
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
Packing Algorithm (P ):
1. if |P | = 1 then return P ;
2. if P is separable then
3.
define two sub-patterns P1 and P2 using a proper guillotine cut;
P 1 = Packing Algorithm (P1 );
4.
5.
P 2 =Packing Algorithm (P2 );
6.
return (P 1 ∪ P 2 );
7 else
8.
remove some items from P and define a separable pattern Q;
9.
return Q;
10. endif
Figure 3.9: The packing algorithm.
Finally, there is a further assumption that is implicit in the algorithm:
4. Given a separable pattern Q, one can define a separable pattern for the associated
item set Q.
Indeed, Theorem 4 ensures that any set of items Q ⊂ P , that produces pattern Q
through the Convexification Algorithm, is separable. Thus, we assume that defining
this set and the associated pattern is not a major issue.
3.2.
Smallest non-separable pattern
In this section we study the structure of any minimum-size pattern that is nonseparable.
3.2.1
Rows and Intersections
Definition 7. (Horizontal Row) An horizontal row is a chain of horizontal edges
(not coincident with the edges of the bin) produced by sides of items consecutively
packed side by side at the same height.
Definition 8. (Vertical Row) A vertical row is a chain of vertical edges (not coincident with the edges of the bin) produced by sides of items consecutively packed at the
same width.
Definition 9. (Intersection) An intersection is the point obtained by one vertical
row and one horizontal row crossing each other.
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
39
Definition 10. (Separable rows) Rows are separable if there exists an edge-to-edge
cut that separates these rows without intersecting none of them, unless this cut is along
an existing intersection.
(a) Non-separable rows
(b) Non-separable rows
(d) Separable rows
(c) Non-separable rows
(e) Separable rows
Figure 3.10: Separable and non-separable rows.
In the following, we will denote by x and y the number of rows and intersections,
respectively; in addition, we will denote by xh and xv the number of horizontal and
vertical rows (with x = xh + xv ).
Lemma 11. For any pattern P it is y ≤ x2 /4.
Proof. Each intersection involves one horizontal and one vertical row, thus y ≤ xh xv .
To prove the statement it is enough to observe that the optimal value of the following
problem
max{y : y = xh xv ; xh + xv = x, xh , xv ≥ 0 integer}
is attained for xh = xv = x/2 (assuming x even) and has value y = x2 /4.
Lemma 12. For any pattern P it is |P | = (x + 1) + y.
Proof. Every increase of x of 1 unit that does not increase y adds 1 item. Obviously
every increase of x can create k new intersections and any intersection is associated
with 4 items, 2 of them were already there, 1 is added either by the increase of x or
by the previous intersection, and the fourth has to be a new item.
Assume P be a pattern obtained through the Convexification Algorithm. Corollary
6 showed that any non-separable pattern P must have |P | ≥ 5. We now go a step
40
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
further and show that the minimum size of a non-separable pattern is 5, and provide
a characterization of such patterns.
Theorem 13. Let P be a pattern generated by the Convexification Algorithm. If
|P | = 5 then P is non-separable.
Proof. Due to Lemmata 11 and 12, |P | = 5 yields either x = 3 and y = 1 or x = 4 and
y = 0. The former is described in Figure 3.11 and corresponds to a separable pattern
that reduces to a single item. As to the latter, we may have (i) xh = 4, xv = 0, or (ii)
xh = 3, xv = 1 or (iii) xv = xh = 2, where the first two cases (depicted in Figure 3.12)
are separable patterns that reduce to a single item. Thus, the only remaining case is
the pattern with xh = xh = 2 and y = 0, depicted in Figure 3.13, that corresponds to
a non-separable pattern.
3
5
2
4
1
Figure 3.11: Pattern with 5 items, x = 3 and y = 1.
5
4
5
4
3
3
2
2
1
1
Figure 3.12: Patterns with 5 items: xh = 4, xv = 0 e y = 0, xh = 3, xv = 1 e y = 0.
2
3
5
1
4
Figure 3.13: Simple Blocked Ring.
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
41
Theorem 13 above motivates the following definition.
Definition 14. (Simple Blocked Ring) A non-separable pattern P is a Simple
Blocked Ring if |P | = 5 with xh = xv = 2 and y = 0.
From the discussion above, it is clear that a Simple Blocked Ring consists of 5 items,
where there is one item (say, item 5) that is centrally placed and touches all the
remaining items, without touching the edges of the bin. In addition, removing item 5
does not produce a separable pattern, whereas removing any of the other four items
leads to a separable pattern. Thus, Simple Blocked Ring is a minimal structure that
may originate non-separability in a given pattern P (assuming P has been generated
by using the Convexification Algorithm of Section 3.1.3). Thus removing any item
from this configuration leads to either the same pattern (if item 5 is removed and the
Convexification Algorithm is re-applied) or to a separable pattern (in case one of the
other four items is removed).
3.3.
Blocked Ring
Definition 15. (Blocked Ring) A non separable pattern P is a Blocked Ring (BR)
if
• |P | ≥ 5, and
• there exists a combination of 2 horizontal and 2 vertical rows non-separable
such that removing all the items not interested by these rows and applying the
Convexification Algorithm yields a Simple Blocked Ring.
3.3.1
Detecting a Blocked Ring
A naive algorithm to detect whether a pattern is a Blocked Ring or not is an O(n4 )
enumeration of all quadruplet of items, checking if (i) they determine two horizontal
and two vertical rows non-separable, and (ii) removing all the remaining items and
applying the Convexification Algorithm yields a Simple Blocked Ring.
A more efficient algorithm for checking if a pattern is a Blocked Ring is as follows:
Noting that the number of combinations to check is at most (xh !)/[(xh − 2)! · 2!] ·
(xv !)/[(xv − 2)! · 2!], i.e., O(n4 ), consider one combination of xh = xv = 2 rows nonseparable at a time. For each combination, apply the following steps:
42
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
1. Identify items interested by the selected rows. We define these items as follows.
Starting from the left edge of the bin we move to the right. When we meet the
first selected vertical row we select all the items placed to its left such that have an
edge completely defined by this row. If we select more than one item we keep just
the one who is intersected by the extension of one of the two selected horizontal
rows. Then we keep moving to the right until we get the second vertical row, in
this case we do the same but items must be placed to its right.
For horizontal rows we apply the same procedure, but in this case starting from
the bottom of the bin. For the first horizontal row we keep item below it while
for the second one item above it.
2. Remove from the bin all the items not interested by horizontal or vertical rows.
3. Apply the Convexification Algorithm.
4. If we obtain a Simple Blocked Ring the original pattern is a Blocked Ring.
We show the steps to detect a Blocked Ring applied to two examples in Figure 3.14.
4
7
3
2
6
5
5
2
9
6
1
3
1
7
4
8
(a) Ex.1: selected rows
(b) Ex.2: selected rows
Figure 3.14: Two examples where we apply the algorithm to detect Blocked Ring.
4
4
3
3
6
6
5
2
1
3
6
5
9
4
9
5
2
1
7
9
2
1
7
7
8
8
8
(a) Selected vertical rows
(b) Item 9 to keep
(c) Item 5 to keep
Figure 3.15: Step 1: Items interested by the selected vertical rows (ex.1).
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
7
43
7
2
2
6
6
1
5
3
2
6
1
5
7
1
5
3
3
4
4
(a) Selected vertical rows
4
(b) Item 3 to keep
(c) Item 6 to keep
Figure 3.16: Step 1: Items interested by the selected vertical rows (ex.2).
4
4
3
3
6
3
6
5
6
5
2
9
4
2
9
1
5
7
2
9
1
1
7
7
8
8
8
(a) Selected horizontal rows
(b) Item 8 to keep
(c) Item 3 to keep
Figure 3.17: Step 1: Items interested by the selected horizontal rows (ex.1).
7
7
2
2
6
1
5
7
1
5
3
2
6
6
5
3
3
4
4
(a) Selected horizontal rows
1
4
(b) Item 4 to keep
(c) Item 7 to keep
Figure 3.18: Step 1: Items interested by the selected horizontal rows (ex.2).
4
4
3
3
6
9
5
2
1
3
6
5
9
5
2
1
7
9
7
8
8
8
(a)
(b)
(c)
Figure 3.19: Step 2: Items to keep (ex.1).
44
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
7
7
2
2
6
5
7
6
1
5
3
6
1
3
3
4
4
(a)
4
(b)
(c)
Figure 3.20: Step 2: Items to keep (ex.2).
3
3
3
5
5
9
5
9
10
9
8
8
(a)
8
(b)
(c)
Figure 3.21: Step 3: Items after Convexification Algorithm execution (ex.1).
7
7
7
6
6
6
8
3
3
3
4
(a)
4
(b)
4
(c)
Figure 3.22: Step 3: Items after Convexification Algorithm execution (ex.2).
Theorem 16. A non separable pattern P always contains a Blocked Ring.
Proof. Let P be a pattern that has been obtained by using the Convexification Algorithm. It is clear that if P contains a Blocked Ring, then P is non separable.
Now by contradiction assume P be non separable but with no Blocked Ring. In this
case doesn’t exist any combination of xv = xh = 2 rows non-separable. Indeed a
such combination yields always a Simple Blocked Ring using the steps to detect a
Blocked Ring. We proved with Theorem 13 that when x ≤ 4 only the combination
xv = xh = 2 yields a non-separable pattern. Therefore P is non-separable if there
exists a combination of rows S, with |S| ≥ 5 and non-separable, that doesn’t contain
any subset of non-separable rows such that xv = xh = 2.
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
45
In a non-separable four rows pattern if we execute an edge-to-edge cut on the row
that we want to separate we perpendicularly intersect another row of the pattern. See
Figure 3.23 where to separate row A we intersect row B.
A
A
D
D
B
C
B
C
(a) Non-separable rows
(b) Cut on row A
Figure 3.23: Edge-to-edge cut on a non-separable rows pattern.
Thus if we want to separate row A we intersect row B, if we want to separate row B
we intersect row C, if we want to separate row C we intersect row D and finally if we
want to separate row D we intersect row A. Let’s indicate such property as follows:
A→B→C→D→A
(3.6)
Furthermore two adjacent rows in 3.6 have always opposite orientation. Namely, respect to Figure 3.23, A is vertical, B is horizontal, C is vertical and D is again horizontal.
Coming back to our pattern S, with |S| ≥ 5 and non-separable, we will have the
following property:
A → B → C → ..... → X − 1 → X → A
(3.7)
Let’s suppose, without loss of generality, that row A is vertical so row B will be
horizontal and we can place it, always without loss of generality, above or below row
A, Figure 3.24a. We know that if we want to separate row X we intersect row A, so,
without loss of generality, we can place row X either on the left or on the right of row
A, Figure 3.24b.
Now to place row C we have three possibilities:
• Pos.1: on the left of row B, Figure 3.24c. In this case we have a subset of four
non-separable rows. This position is non feasible.
• Pos.2: on the right of row B, Figure 3.24d. In this case we are diverging, that is
the last row placed, or its extensions, don’t intersect any of the previous placed
rows.
46
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
• Pos.3: we extend row B so that it passes row X and place row C on the left of
row B, Figure 3.24e. In this case we are diverging too.
A
A
A
X
X
B
B
(a) Rows A and B
(b) Rows A, B and X
B
C
(c) Rows A, B, C and X
A
A
X
X
B
C
(d) Rows A, B, C and X
B
C
(e) Rows A, B, C and X
Figure 3.24: How to place row C.
What we have seen for the positioning of row C is repeated, with the proper adjustments, for all the subsequent rows. Let’s now consider how to place row D, we have
two different initial situations to consider: Figure 3.24d and 3.24e.
Let’s start from Figure 3.24d. To place row D we have the same three positions of
row C, with above and below instead of right and left. We remind that if we want to
separate row C we intersect row D.
• Pos.1: above row C, Figure 3.25a. In this case we have a subset of four nonseparable rows. This position is non feasible.
• Pos.2: below row C, Figure 3.25b. In this case we are diverging, that is the last
row placed, or its extensions, don’t intersect any of the previous placed rows.
• Pos.3: we extend row C so that it passes row A and place row D above row C,
Figure 3.25c. In this case we are diverging too.
Let’s now consider Figure 3.24e. We still have the same three position to place row D:
• Pos.1: above row C, Figure 3.26a. In this case we have a subset of four nonseparable rows. This position is non feasible.
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
47
D
A
A
A
D
X
X
X
B
B
B
D
C
(a) Rows A, B, C, D, X
C
(b) Rows A, B, C, D, X
C
(c) Rows A, B, C, D, X
Figure 3.25: How to place row D (case 1).
• Pos.2: below row C, Figure 3.26b. In this case we are diverging, that is the last
row placed, or its extensions, don’t intersect any of the previous placed rows.
• Pos.3: we extend row C so that it passes row A and place row D above row C,
Figure 3.26c. In this case we are diverging too.
D
A
A
A
D
X
X
B
C
(a) Rows A, B, C D, X
X
B
D
C
(b) Rows A, B, C D, X
B
C
(c) Rows A, B, C D, X
Figure 3.26: How to place row D (case 2).
We can state that each row can be theoretically placed in three positions, obviously
above, below, right and left must be evaluated case by case. Our pattern S is nonseparable if property 3.7 is verified. This property has its own circularity, indeed we
have A → B...X → A, so rows can’t be always divergent. This mean we can’t use Pos.2
or Pos.3 to place row X, because its extensions won’t intersect row A. Therefore we
have to use Pos.1, however this choice yields a combination xv = xh = 2 non-separable
contradicting our initial statement. Hence it isn’t possible to have a pattern S, with
S ≥ 5 and non-separable, that does’t contain any subset of non-separable rows such
that xv = xh = 2.
48
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
3.4.
Blocked Ring characterization
In this section we give a characterization of non-separable patterns in terms of rows
and intersections.
3.4.1
Single Blocked Ring
Definition 17. (Single Blocked Ring) A Blocked Ring is a Single Blocked Ring if
all the Simple Blocked Rings, obtained with the algorithm to identify Blocked Ring,
share at least an item and the removal of this item gives a separable pattern.
Observe that the Simple Blocked Ring described in Section 3.2 is indeed a Single
Blocked Ring. However, the family of Single Blocked Rings includes more complex
patterns, as, e.g., the one depicted in Figure 3.27a.
7
7
2
2
6
5
5
1
6
5
3
1
3
4
(a) |P | = 7
2
6
1
3
7
4
4
(b) {(1),(2),(3),(4)}
(c) {(3),(4),(6),(7)}
7
2
6
5
1
3
4
(d) {(2),(3),(4),(6)}
Figure 3.27: Single Blocked Ring.
In fig.3.27 if we consider rows xh = xv = 2 non-separable we have three possible
combinations, and so group of items, that give Simple Blocked Ring after applying the
Convexification Algorithm.
• (1), (2), (3), (4)
• (3), (4), (6), (7)
• (2), (3), (4), (6)
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
49
These Simple Blocked Rings share (3) and (4), this means that the removal of item (3)
or (4) gives guillotinable pattern.
3.4.2
Multiple Blocked Ring
Definition 18. (Multiple Blocked Ring) A Blocked Ring that is not a Single
Blocked Ring is called Multiple Blocked Ring.
By definition, for Multiple Blocked Ring, there is no item that belongs to all the Simple
Blocked Rings obtained with the algorithm to identify Blocked Ring.
Multiple Blocked Ring can be:
• Nested Blocked Ring.
• Concatenated Blocked Ring.
• Complex Blocked Ring. It combines proprieties of Nested Blocked Ring and
Concatenated Blocked Ring.
Definition 19. (Nested Blocked Ring) A Multiple Blocked Ring is a Nested Blocked
Ring if all the Simple Blocked Rings, obtained with the algorithm to identify Blocked
Ring, don’t share any item.
2
6
2
6
10 11 7 3
13
1 5 9 12
10 11 7 3
13
1 5 9 12
8
4
(a) |P | = 13
2
6
8
4
(b) {(9),(10),(11),(12)}
10 11 7 3
13
1 5 9 12
8
4
(c) {(5),(6),(7),(8)}
2
6
10 11 7 3
13
1 5 9 12
8
4
(d) {(1),(2),(3),(4)}
Figure 3.28: Nested Blocked Ring.
In Figure 3.28 if we consider the rows xh = xv = 2 non-separable we have three possible
combinations, and so group of items, that give Simple Blocked Ring after applying the
Convexification Algorithm.
50
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
• (9), (10), (11), (12)
• (5), (6), (7), (8)
• (1), (2), (3), (4)
These Simple Blocked Rings don’t share any item, so we have a Nested Blocked Ring.
To have a guillotinable pattern all the Simple Blocked Rings detected must be guillotinable, so we have to remove an item from each of them.
Definition 20. (Concatenated Blocked Ring) A Multiple Blocked Ring is a Concatenated Blocked Ring if each Simple Blocked Ring, obtained with the algorithm to
identify Blocked Ring, shares at least an item with another Simple Blocked Ring.
4
4
3
3
6
5
2
9
1
7
2
9
1
7
7
8
8
8
(a) |P | = 9
(b) {(3),(5),(8),(9)}
(c) {(3),(6),(8),(9)}
4
4
3
3
6
6
5
2
1
4
3
6
5
9
6
5
2
1
3
6
5
9
4
5
2
9
1
7
9
2
1
7
7
8
8
8
(d) {(4),(6),(8),(9)}
(e) {(1),(2),(4),(6)}
(f) {(1),(4),(6),(9)}
4
3
6
5
9
2
1
7
8
(g) {(2),(6),(7),(8)}
Figure 3.29: Concatenated Blocked Ring.
In Figure 3.29 if we consider just the rows xh = xv = 2 non-separable we have six
possible combinations, and so group of items, that give Simple Blocked Ring after
applying the Convexification Algorithm.
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
51
• (3), (5), (8), (9)
• (3), (6), (8), (9)
• (4), (6), (8), (9)
• (1), (2), (4), (6)
• (1), (4), (6), (9)
• (2), (6), (7), (8)
There isn’t any item shared by all the Simple Blocked Rings, but each Simple Blocked
Ring shares at least an item with another Simple Blocked Ring, so we have a Concatenated Blocked Ring. To have a guillotinable pattern all the Simple Blocked Rings
detected must be guillotinable, so, for example, we can remove item (4) and (8).
Definition 21. (Complex Blocked Ring) A Multiple Blocked Ring is a Complex
Blocked Ring if we have two or more Simple Blocked Rings, obtained with the algorithm
to identify Blocked Ring, where each of them share at least an item with another
Simple Blocked Ring and one or more Simple Blocked Rings, always obtained with the
algorithm to identify Blocked Ring, that don’t share any item.
11
7
4
8
1
11
7
3
5
6
10
4
2
1
8
9
11
7
3
5
6
10
4
2
1
8
9
(a) |P | = 11
11
7
8
1
10
2
(c) {(6),(7),(8),(9)}
11
7
3
5
5
6
9
(b) {(1),(2),(3),(4)}
4
3
6
10
2
9
(d) {(7),(8),(9),(10)}
4
8
1
3
5
6
10
2
9
(e) {(8),(9),(10),(11)}
Figure 3.30: Complex Blocked Ring.
Figure 3.30 shows a Complex Blocked Ring. Indeed in Figure 3.30b we have the Simple
Blocked Ring with no item shared with others, while in Figure 3.30c, 3.30d, 3.30e we
have the Simple Blocked Rings that share items. To have a guillotinable pattern all the
Simple Blocked Rings detected must be guillotinable, so we can remove, for example,
item (1) and (8).
52
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
3.5.
Worst-case analysis
In this section we consider problems P1 and P2 introduced in Section 3.1 and provide
answers to these problems in some special cases. Since our analysis considers one
pattern at a time, we distinguish cases depending on the structure of the current
pattern. Recall that, in all cases, we assume the current pattern P be produced by the
execution of the Convexification Algorithm described in section 3.1.3. In addition, we
assume P be non-separable, since otherwise no action is required.
In Section 3.5.1 we solve problems P1 and P2 for the simplest case in which P is a
Simple Blocked Ring. In Section 3.5.2 we consider the case in which P is a Single
Blocked Ring. Finally, we leave as open problem the solution of P1 and P2 in case P
is a Multiple Blocked Ring.
As to problem P2 we can consider one bin at a time since asymptotic and easily
compute a lower bound on PoG as follows
Theorem 22.
P oG ≥ 4/3
Proof. Consider the following instance, composed of
• 2k items of type a: wj = 3/5 and hj = 2/3,
• 2k items of type b: wj = 2/5 and hj = 3/5, and
• k items of type c: wj = hj = 1/5,
for some integer k. All items have to be packed into 1 × 1 bins. An optimal 2BP|O|F
solution is composed of k bins that identical to that depicted in Figure 3.31.
a
b
c
b
a
Figure 3.31: Non guillotinable pattern.
It is easy to see that any guillotinable pattern may include at most 2 items of type a
and one item of the type b (or viceversa), and one item of type c. This means that an
optimal 2BP|O|G solution requires 4k bins to pack 6k items of types a and b and 3k
items of type c, whereas an optimal 2BP|O|F solution would pack these items into 3k
bins. This proves the theorem.
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
3.5.1
53
Case 1: P is a Simple Blocked Ring
In this section we consider the case in which P is a Simple Blocked Ring.
Theorem 23. If P is a Simple Blocked Ring
M A(P ) = 1/4
Proof. Since P is a Simple Blocked Ring, it has the structure described in Section 3.2.1,
i.e., |P | = 5 and there is a central item (say 5) that touches all the other 4 items. By
an obvious average argument, there exists one item among the first four whose area is
at most 1/4 the area of the bin. Removing this item yields a separable pattern Q. By
Theorem 4 any set of items that yield Q by means of the Convexification Algorithm is
separable.
To prove that the result is tight, consider an instance in which items 1, 2, 3, 4 have
the same area and item 5 is arbitrarily small. Then, the area one has to remove to
produce a separable pattern is arbitrarily close to 1/4 the area of the bin.
Theorem 24. If P consists of one or more Simple Blocked Rings patterns, then
P oG = 4/3
Proof. From each triplet of bins in the solution that share the same pattern P , define
four bins as follows: for i = 1, 2, 3 bin i packs all items but item i, and there is a fourth
bin that packs items 1, 2, 3, at the same coordinates as in P . Thus, the ratio between
the optimal 2BP|O|G solution and the given 2BP|O|F solution cannot be larger than
4/3. Combining this with Theorem 22 settles the exact value of P oG = 4/3 in this
special case.
3.5.2
Case 2: P is a Single Blocked Ring
The mathematical characterization of Section 3.4.1 yields that, if P is a Single Blocked
Ring there exists a set of (say) Q quadruplet of items that correspond to Simple Blocked
Rings and that share at least one item.
This produces the following result
Theorem 25. If P is a Single Blocked Ring
M A(P ) = 1/3
Proof. Denote by (wu , hu ) and (xu , yu ) the dimensions and packing coordinates for
each item u ∈ P . We assign at most one color among Yellow, Red and Blue to each
54
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
item u. These three colors represent a partition of items in three subsets. We want to
prove that removing any colored subset we have a separable pattern.
We know there exists an item j that is common to all the quadruplets. In the particular
case where there are two items (j, k) that are common to all the quadruplets, the
coloring is easy: j is Yellow, k is Red and all the other items are Blue. So let’s consider
the worst case where we have exactly one item j in common to all the quadruplets.
The first coloring, Yellow, is easy, it consists only of item j. We know that removing
item j we have a separable pattern. Red items are those who don’t allow item j to be
separated with vertical cuts. So we consider the vertical cuts x = xj and x = xj + wj
and we color of Red all the items intercepted by these cuts. The pattern we have
removing only Red items is separable. Indeed, if we remove Red items, by definition,
we can cut item j with two vertical cuts. Once removed item j the rest is obviously
separable.
Similarly we color of Blue all the items that are intercepted by horizontal cuts y = yj
and y = yj + hj ; the pattern without Blue items is separable too. By an obvious
average argument, there exists one subset among Yellow, Red and Blue whose area is
at most 1/3 the area of the bin. Removing this subset yields a separable pattern Q.
To prove that the results is tight, consider the instance depicted in Figure 3.32 that
corresponds to a pattern that has 8 items. In this case one can partition the items into
3 subsets, namely {2}, {1, 8} and {4, 7} such that
• each subset of items is separable
• removing any subset of items produces a separable pattern.
In the worst-case, all the three subsets have the same area, while the remaining items
have a negligible area. Thus, the minimum area M A that one has to remove to produce
a separable pattern is arbitrarily close to 1/3.
2
7
1
6
5
3
8
4
Figure 3.32: Worst-case for problem P1 when P is a Single Blocked Ring.
More in general, the problem of computing M A(P ) for a given pattern P can be stated
as follows.
Removal Problem: Given a set P of items and a set of q quadruplets Qi (i =
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
55
1, . . . , q), determine a partition of the items into (say) t subsets S1 , . . . St such that each
subset Sk includes (i) at least one item and (ii) at most 3 items from each quadruplet
Qi .
Condition (i) ensures that removing all items from any subset Sk provides a guillotinable pattern, whereas (ii) ensures that the set of items that have been removed produces
itself a guillotinable pattern. Thus, using a reasoning similar to that used in the proof
of Theorem 23, if a t-partitioning of item set P is found, removing at most 1/t of the
area of the bin one can get a separable pattern P , i.e., M A(P ) ≤ 1/t. In order to
minimize the area that one has to remove to define P , it is natural to maximize the
number of subsets of the partition.
Noting that t ≤ |P | and using the following binary variables
(
yk =
(
xjk =
1 if subset k is generated;
0 otherwise
(k = 1, . . . , |P |)
1 if item j is included in subset k;
0 otherwise
(j ∈ P ; k = 1, . . . , |P |)
(3.8)
(3.9)
one can derive the following mathematical model for the problem at hand.
max t =
X
yk
(3.10)
k
X
xjk ≥ yk
∀k, ∀i
(3.11)
xjk ≤ 3yk
∀k, ∀i
(3.12)
∀j
(3.13)
∀j, ∀k
(3.14)
j∈Qi
X
j∈Qi
X
xjk ≤ 1
k
yk , xjk ∈ {0, 1}
Objective function (3.10) maximizes the number of subsets that are generated. Constraints (3.11)–(3.12) impose that each selected subset has at least one and at most
three items from each quadruplet. Finally, inequalities (3.13) ensure that each item
belongs to at most one subset in the partition, whereas (3.14) impose all variables be
binary.
If we apply Model (3.10)–(3.14) to the pattern depicted in Figure 3.32 we obtain three
subsets, namely {2}, {1, 8} and {4, 7}. This model and those described in the following
can be also applied to Multiple Blocked Ring.
56
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
In a similar way, let us consider the problem of computing the value of the Price of
Guillotinability for a given item set P ; this value will be denoted as P oG(P ) and we
P
have P oG = P P oG(P ).
Observe that any feasible solution of value (say) t to model (3.10)–(3.14) provides a
guillotinable solution for the given item set P ; the value of this 2BP|O|G solution
implicitly gives an upper bound for P oG(P ). Indeed, as in the proof of Theorem
24, one can define a set of t guillotine patterns that pack all the items packed in
t − 1 bins in an 2BP|O|F solution: each bin i (i = 1, . . . , t) contains all the items
in the original pattern but those belonging to the i-th partition of the item set. As
the optimal 2BP|O|G solution cannot be worse than this solution, we conclude that
t
.
P oG(P ) ≤ t−1
As P oG(P ) concerns an asymptotic ratio, one can exploit the availability of multiple
copies of the items. In this view one can partition the content of (say) t − D bins
of a 2BP|O|F solution into t subsets of items, each producing a guillotinable pattern;
this means that one has to consider that each item j can be inserted in (at most) D
subsets, i.e., it can be removed by at most D bins from the initial solution. Thus, the
model for computing P oG(P ) is as follows
t
t−D
X
t=
yk
(3.15)
min
(3.16)
k
X
xjk ≥ yk
∀k, ∀i
(3.17)
xjk ≤ 3yk
∀k, ∀i
(3.18)
∀j
(3.19)
∀j, ∀k
(3.20)
∀k
(3.21)
j∈Qi
X
j∈Qi
X
xjk yk ≤ D
k
xjk ∈ {0, 1}
yk ≥ 0 integer
D ≥ 0 integer
(3.22)
where variables yk represent the number of times each pattern k is selected, and D
is a new variable that indicates the maximum number of copies of each item that are
used, i.e., the maximum number of copies of each item that one is allowed to leave
unpacked. The new objective function (3.15) minimizes P oG(P ), which is given by
the ratio between the number of guillotine patterns that are produced and the number
of bins that are considered in the 2BP|O|F solution.
Model (3.15)–(3.22) is highly nonlinear in that
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
57
• the objective function is nonlinear with respect to variables t and D; and
• constraints (3.19) include the product between x and y variables.
To resume to a linear objective function, one can solve the model several times, for
different (and fixed) values of D – that becomes a parameter in these settings. Thus,
one has to minimize a decreasing convex function in t, which is equivalent to maximize
variable t. As to the remaining nonlinearities, a straightforward way to linearize products that include a binary variable is to introduce additional variables αjk that denote
the number of copies of item j that are actually inserted in subset k.
For a given value of D the model reads as follows
X
max t
(3.23)
yk = t
(3.24)
k
X
xjk ≥ yk
∀k, ∀i
(3.25)
xjk ≤ 3yk
∀k, ∀i
(3.26)
∀j
(3.27)
∀j, ∀k
(3.28)
∀k
(3.29)
αjk ≥ yk − M (1 − xjk )
∀j, ∀k
(3.30)
αjk ≥ 0 integer
∀j, ∀k
(3.31)
j∈Qi
X
j∈Qi
X
αjk ≤ D
k
xjk ∈ {0, 1}
yk ≥ 0 integer
where constraints (3.30)–(3.31) are used to link α variables to x and y variables, and
M is a large coefficient.
P
Back to problem P2, recall that we are interested in computing P oG = P P oG(P ),
i.e., our aim is to determine the value of the Price of Guillotinability for the worst-case
P . We can prove the following result
Theorem 26. If P consists of one or more Single Blocked Rings patterns, then
7
3
≤ P oG ≤
5
2
Proof. As to the upper bound, note that Theorem 25 implicitly provides a solution to
model (3.15)–(3.22) with t = 3 and D = 1. This yields a 2BP|O|G solution which uses
a number of bins equal to 3/2 of the number of bins required by any 2BP|O|F solution.
58
Chapter 3 Two-Dimensional Bin Packing: the 2BP|O|G case
Now consider the instance depicted in Figure 3.32. The optimal solution of model
(3.15)–(3.22) provides t = 7 and D = 2, and is given by the following item sets: {2},
{4, 8} and {1, 7}, {3, 8}, {1, 3, 5} and {4, 7} where the first item set is taken twice. This
implies that given 5 bins of the 2BP|O|F solution one can construct a 7-bins solution
to 2BP|O|G i.e., P oG(P ) ≥ 7/5, which provides a valid lower bound on P oG.
Chapter 4
Partial enumeration algorithms
for 2BP|O|G
4.1.
Introduction
In 1 the Two-Dimensional Bin Packing Problem (2BP) one is requested to pack a given
set of small rectangular items into a minimum number of larger rectangular bins. Items
must be packed without overlapping and orthogonally, with their edges parallel to the
edges of the bin. As packing items into bins also models the problem of cutting items
from larger sheets, this problem finds several applications in different contexts, e.g., in
cutting wood or glass, loading boxes into vehicles, warehousing of goods, newspapers
pagination, and telecommunications among others (see, e.g., [45], [73], [51]).
According to the specific application at hand and to the type of patterns that may be
produced, many 2BP variants have been studied so far in the literature. A relevant case
arises when one is allowed to rotate items by 90 degrees, to possibly achieve a better
usage of the bin area. Note that rotation can be allowed for a subset of items only,
whereas it should be avoided in case the bin has special features (e.g., it is a decorated
piece of glass). Another relevant special case is to produce k-staged patterns, i.e.,
solutions in which each item can be obtained with a sequence of (at most) k edge to
edge cuts parallel to the edges of the bin. This kind of problems, introduced in [32],
is motivated in applications in which automatic machines are used to cut the items,
and some cost is incurred for each cut that is executed. Many papers in the literature
addressed the case in which k = 2, i.e., where items have to be packed into levels.
Integer Linear Programming (ILP) models for level packing with a polynomial number
of variables and constraints were given in [49, 56], and were extended to the case k = 3
in [66]. The problem in which no explicit bound is imposed on the number of cuts
1
This chapter is based on: A. Lodi, M. Monaci, E. Pietrobuoni, ”Partial enumeration algorithms
for Two-Dimensional Bin Packing Problem with Guillotine Constraints”. submitted for publication.
59
60
Chapter 4 Partial enumeration algorithms for 2BP|O|G
that are allowed is known as the Two-Dimensional Guilloting Bin Packing. Figure 4.1
shows an example of a non guillotine pattern for a given set of items (left), as well as
a packing of the same items that satisfies the guillotine requirement (right).
2
2
3
4
1
1
4
3
5
5
Figure 4.1: Example of non guillotine and guillotine patterns.
In this chapter we consider the Two-Dimensional Guillotine Bin Packing, which we will
denote by 2BP|O|G according to the three-field notation proposed in Lodi, Martello,
Vigo [53]; similarly, the problem in which guillotine constraint is not imposed will be
denoted as 2BP|O|F. In addition, we will denote by N = {1, . . . , n} the set of items to
cut, the j-th having width wj and height hj , and by W and H the sizes of the bins.
Finally, we assume without loss of generality that all input data are integer numbers.
An exact algorithm based on integrating column generation and constraint programming for solving both 2BP|O|F and 2BP|O|G was given in [64], whereas in [21] a
dynamic programming algorithm was used to solve a related two-dimensional packing
problem. As far as heuristic solutions are concerned, we observe that many algorithms
for 2BP discussed in Section 2.7.2 and 2.7.3 (e.g., finite-best-strip and finite-first-fit [5],
floor-ceiling and knapsack-heuristics [53]) pack items according to a 2-staged policy,
hence producing patterns that are guillotinable. As to heuristic specifically devoted
to 2BP|O|G we mention the agent-based algorithm proposed in [65], a constructive
heuristic given in [13] and the three insertion heuristics introduced in [27]. A number
of alternative methods for solving Two-Dimensional Bin Packing problems is given in
[42].
In this chapter we propose a new heuristic algorithm, for the 2BP|O|G, based on partial
enumeration, and computationally evaluate its performance on a large set of instances
from the literature. Computational experiments show that the algorithm is able to
produce proven optimal solutions for a large number of problems, and gives a tight
approximation of the optimum in the remaining cases.
The chapter is organized as follows. In Section 4.2 we give the general idea of our
approach, while improvements over the basic version of the algorithm are discussed
Chapter 4 Partial enumeration algorithms for 2BP|O|G
61
in Section 4.3. Section 4.4 reports our computational experiments on a large set of
instances from the literature, while Section 4.5 draws some conclusions.
4.2.
Basic Heuristic Algorithm
Our algorithm is based on an enumeration tree that defines, at each level p, the current
content for the p-th bin in the solution. The algorithm is heuristic in nature, in that
not all possible feasible ways of packing the bins are taken into account. Leaf nodes
correspond to complete solutions, in which all items have been packed. Intermediate
nodes have a number of descendant nodes, associated with different ways to pack the
next bin in a guillotine way. In particular, we use a set S of selection rules to determine
the next item to pack (and its position in the bin) and a set G of guillotine split rules
to satisfy the guillotine requirement, and generate a descendant node for each pair
(s, g) with s ∈ S and g ∈ G. The search tree is explored according to a depth-first
strategy, by considering descendant nodes according to the selection rule and then by
the guillotine split rule. Obviously, if a feasible solution is found with value, say z, no
descendant nodes are generated from nodes at level z − 1.
Given a selection rule s ∈ S and a guillotine split rule g ∈ G, the corresponding
descendant node is obtained by applying the packing strategy described in Section
4.2.1. The sets of selection rules and guillotine split rules used in the algorithm are
described in Sections 4.2.2 and 4.2.3, respectively.
4.2.1
Packing the current bin
In this section we describe the packing strategy that is used, at each node, to pack the
current bin. We will denote by J ⊆ N the set of items that have not been allocated
in the previous bins (i.e., in the previous levels of the tree). Recall that each node
implements a fixed selection rule and a fixed guillotine split rule.
Our packing strategy packs one item at a time in the free space of the bin, so as to
guarantee that a guillotinable pattern is obtained. In particular, we maintain a list
F = {F1 , . . . , Fm } of pairwise disjoint free rectangles where the items in J can be
allocated. Initially, F = {F1 }, i.e., there is only one rectangle that corresponds to the
entire bin.
At each iteration, we determine the set P of pairs (j, Fi ) associated with feasible
packings of an item j ∈ J in a free rectangle Fi ∈ F and compute, for each such
pair, an insertion score according to the given selection rule. The pair, say (j ∗ , Fi∗ )
that produces a minimum is selected, item j ∗ is packed with its bottom left corner
in the bottom left corner position of rectangle Fi∗ , and it is eliminated from J. The
selected rectangle is then removed from F, and split using the given guillotine split
62
Chapter 4 Partial enumeration algorithms for 2BP|O|G
rule, to possibly produce two smaller free rectangles that are inserted in F. Finally,
free rectangles are scanned to check if pairs of rectangles exist that can be merged into
a unique larger rectangle. The current bin is closed if J = ∅, or F = ∅ or no item j ∈ J
can be inserted in any free rectangle Fi ∈ F.
A pseudocode implementation of the algorithm is given in Figure 4.2, where we assume
the algorithm receives on input
• the set J of unpacked items,
• the sizes W and H of the bin,
• a function s(j, Fi ) that returns the insertion score for item j ∈ J into free rectangle Fi , and
• a function g(j, Fi ) that returns a possibly empty set of free rectangles obtained
cutting item j from rectangle Fi .
Algorithm GuillotineBin:
define an initial W × H rectangle F1 at position(0, 0) and set F = {F1 };
repeat
let P be the set of all pairs (j, Fi ) such that item j ∈ J can be inserted in free
rectangle Fi ∈ F;
if P =
6 ∅ then
let (j ∗ , Fi∗ ) = arg min{s(j, Fi ) : (j, Fi ) ∈ P};
pack item j ∗ in rectangle Fi∗ and set J := J \ {j ∗ };
set F := F \ {Fi∗ } ∪ g(j, Fi∗ );
endif
until P = ∅;
Figure 4.2: Algorithm to pack a single bin.
4.2.2
Selection rule
Selection rules are used to simultaneously select the next item to be allocated and the
associated free rectangle–recall that an item is always placed with its bottom left corner
in the bottom left corner position of the selected rectangle. All the rules compute a
score for each pair (j, Fi ) that indicates the “quality” of the packing. The smaller the
better when the scores of two distinct pairs (j, Fi ) are compared. In case a pair, say
s(j, Fi ), is found such that the current item j perfectly fits the current free rectangle
Fi , we set s(j, Fi ) = −∞, i.e., we pack item j into rectangle Fi without computing the
remaining scores. Similarly, we assume that s(j, Fi ) = ∞ in case item j does not fit
into rectangle Fi .
Let Wi and Hi denote the width and the height, respectively, of the free rectangle Fi .
The following three different rules were used to perform the choice.
Chapter 4 Partial enumeration algorithms for 2BP|O|G
63
1. Best Area: sBA (j, Fi ) = Wi Hi − wj hj
2. Best Short Side: sBSS (j, Fi ) = min(Wi − wj , Hi − hj )
3. Best Long Side: sBLS (j, Fi ) = max(Wi − wj , Hi − hj )
These rules minimize the unused area in the free rectangle, the length of the shorter
leftover side and the length of the longer leftover side, respectively. Similar rules were
used in [42], together with rules that maximize these figures, to determine the best
free rectangle to pack a given item; differently, we use selection rules to simultaneously
determine the next item to pack and the associated packing position.
4.2.3
Guillotine split rule
Let j and Fi denote the item and the free rectangle, respectively, that have been
determined using some selection rule. The algorithm packs item j with its bottom left
corner in the bottom left corner of rectangle Fi , producing a L-shaped free space. This
free space can be split into two new free rectangles, either with a horizontal or with a
vertical cut, as shown in Figure 4.3. In the former case, two new free rectangles are
generated with sizes Wi , Hi − hj and Wi − wj , hj , respectively. If instead the cut is
vertical, the two new rectangles have sizes wj , Hi − hj and Wi − wj , Hi , respectively. In
both cases, if wj = Wi or hj = Hi only one rectangle is produced, whereas no rectangle
is created if both equalities hold.
2
2
Fa
Fa
Hi
3
1
Fb
Hi
3
1
j
Fb
Wi
j
Wi
Figure 4.3: Example of horizontal (left) and vertical (right) guillotine cut.
We implemented a number of different strategies proposed in [42] to determine the
type of cut to produce; preliminary computational experiments suggested to use three
of them in our algorithm, namely:
1. Longer Leftover: cut is horizontal if Wi − wj ≥ Hi − hj , and vertical otherwise;
2. Shorter Leftover: cut is horizontal if Wi −wj < Hi −hj , and vertical otherwise;
64
Chapter 4 Partial enumeration algorithms for 2BP|O|G
3. Min Area: cut is horizontal if hj (Wi −wj ) < wj (Hi −hj ), and vertical otherwise.
The first two split rules select the cut direction according to the longer and shorter
leftover side, respectively, whereas the third one is aimed at producing two new free
rectangles having a similar area.
4.3.
Enhanced Heuristic Algorithm
The basic scheme described in Section 4.2 can lead to search trees with a very large
number of nodes, even for small instances. Indeed, combining the three selection rules
with the three guillotine split rules, provides nine potentially different children for each
node. This means that the number of nodes at the p-th level of the search tree is 9p ,
which can be extremely large even for small values of p. In this section we present two
ways to improve the algorithm: the first one, described in the next section, is aimed at
avoiding the multiple generation of decision nodes producing the same pattern, whereas
the second one is a heuristic pruning of the nodes, as described in Section 4.3.2.
4.3.1
Removing duplicated nodes
Consider a certain node, say d at a given level p of the search tree. Let (s1 , g1 ) and
(s2 , g2 ) denote two possible descendant nodes associated with different selection rules
s1 , s2 ∈ S and/or different guillotine split rules g1 , g2 ∈ G. Though the rules used in
the two nodes are different, the packing strategy may produce two (possibly different)
patterns that pack the same subset of items. In this case, the subtrees descending from
these two nodes would be absolutely identical, and exploring both of them would be a
waste of time.
To avoid these situations, the basic scheme has to be modified so as to generate descendant nodes only for those patterns that pack a different subsets of items. In principle,
one should compare the set of unpacked items after processing node d, say J(d), with
the same set after each node of level p has been processed, possibly fathoming the
current node. As this check could be time consuming, we only compare J(d) with the
same set produced by brother nodes, i.e., nodes at level p that have been generated by
the same node using different selection and/or guillotine split rules.
4.3.2
Heuristic pruning
Our second strategy is a heuristic pruning of some nodes of the search tree, according
P
to the current partial solution. Let A = j∈N wj hj and z be the total area of the items
and the value of an incumbent solution, respectively (initially, z = n). In addition,
Chapter 4 Partial enumeration algorithms for 2BP|O|G
65
remind that J(d) denotes the set of items that are still unpacked after the exploration
of a given node d at level p.
We compute the average filling of each bin in the partial solution at the current node
d, say AV , and we compare this value with a measure of the average filling of each bin
in a solution using one bin less than the current incumbent. In particular, if condition
P
A − j∈J(d) wj hj
A
AV :=
≤α
(4.1)
pW H
(z − 1)W H
is satisfied, we fathom the current node. The rationale is that the current solution
has an average filling of the already used bins that is unlikely to lead to improve the
incumbent. The value of the parameter α in (4.1) is updated during the execution
of the algorithm: initially, we set α = 0, i.e., at the beginning no node is pruned.
After we explored a number, say N1 , of nodes without improving the incumbent, we
increase the value of α by a quantity δ, to avoid complete enumeration. The increase
of parameter α (up to 1) is possibly repeated every N2 non-improving nodes.
4.4.
Computational experiments
The basic algorithm described in Section 4.2 (denoted as BSC in the following) and its
enhanced version (ENH) of Section 4.3 were coded in C language and tested on an Intel
Xeon E3-1220V2 machine running at 3.10 GHz on a large set of instances proposed
in the literature. Preliminary computational experiments suggested to set N1 = 500,
N2 = 500 and δ = 0.1 for algorithm ENH. As a benchmark, we considered the ten classes
of instances proposed in [5] and in [61] for 2BP. Each class includes 50 instances (10
instances for each value of n ∈ {20, 40, 60, 80, 100}), so a set of 500 instances has been
considered.
The first six classes proposed by Berkey and Wang [5] are so characterized:
Class I : wj and hj uniformly random in [1,10], W = H = 10;
Class II : wj and hj uniformly random in [1,10], W = H = 30;
Class III : wj and hj uniformly random in [1,35], W = H = 40;
Class VI : wj and hj uniformly random in [1,35], W = H = 100;
Class V : wj and hj uniformly random in [1,100], W = H = 100;
Class VI : wj and hj uniformly random in [1,100], W = H = 300;
In the last four classes, proposed by Martello and Vigo [61], the items are classified in
four types:
66
Chapter 4 Partial enumeration algorithms for 2BP|O|G
Type 1 : wj uniformly random in [ 23 W, W ], hj uniformly random in [1, 21 H];
Type 2 : wj uniformly random in [1, 12 W ], hj uniformly random in [ 23 H, H];
Type 3 : wj uniformly random in [ 12 W, W ], hj uniformly random in [ 12 H, H];
Type 4 : wj uniformly random in [1, 12 W ], hj uniformly random in [1, 12 H];
The bin sizes are W = H = 100 for all classes, while the items are as follows:
Class VII : type 1 with probability 70%, type 2,3,4 with probability 10% each;
Class VIII : type 2 with probability 70%, type 1,3,4 with probability 10% each;
Class IX : type 3 with probability 70%, type 1,2,4 with probability 10% each;
Class X : type 4 with probability 70%, type 1,2,3 with probability 10% each;
Tables 4.1 and 4.2 report the outcome of our experiments for algorithms BSC and ENH,
respectively. Each algorithm was tested using different time limits, namely 60, 600 and
1,800 CPU seconds. Each line of the tables refers to a given class and value of n, i.e.,
it summarizes ten instances. For each considered time limit, the tables report
• the sum of the best solution found by our heuristic algorithm,
• the number of instances for which the solution found is provably optimal,
• the average percentage error – for each instance the percentage error is given by
(U − L)/L, where U is the value of the solution found by the algorithm and L
denotes the best known lower bound value.
In addition, we report, for each class and value of n, the sum of the best known lower
bounds for the ten 2BP|O|F instances, i.e., when guillotine constraint is not imposed.2
Noting that 2BP|O|F is a relaxation of 2BP|O|G, this figure provides a lower bound
on the optimal solution value. Finally, the last line of each table gives the same figures
with respect to the whole benchmark.
Our computational experiments show that, even with the smallest time limit of 60
seconds, the basic algorithm is able to find the optimal solution value in 361 out of
the 500 instances, and has an average error below 3.6%. The improvements that can
be obtained with a larger time limit are limited but regular: with 1,800 seconds, the
algorithm saves overall 24 bins, and proves optimality for 20 more instances, with an
average gap below 3.4%. Noting that the produced solutions are compared with lower
2
The best 2BP|O|F lower and upper bounds are taken from [62] and are available at www.or.deis.
unibo.it/research_pages/ORinstances/ORinstances.htm
Chapter 4 Partial enumeration algorithms for 2BP|O|G
class
n
20
40
1
60
80
100
20
40
2
60
80
100
20
40
3
60
80
100
20
40
4
60
80
100
20
40
5
60
80
100
20
40
6
60
80
100
20
40
7
60
80
100
20
40
8
60
80
100
20
40
9
60
80
100
20
40
10
60
80
100
Global
LB
71
134
197
274
317
10
19
25
31
39
51
92
136
187
221
10
19
23
30
37
65
119
179
241
279
10
15
21
30
32
55
109
156
224
269
58
112
159
223
274
143
278
437
577
695
42
74
98
123
153
7173
UB
71
134
200
275
318
10
20
25
32
39
54
96
141
195
230
10
19
25
33
39
66
119
182
247
288
10
19
22
30
35
55
113
162
235
279
58
114
163
230
282
143
278
437
577
695
44
74
103
130
163
7319
TL=60
#opt
10
10
7
9
9
10
9
10
9
10
7
6
5
2
2
10
10
8
7
8
9
10
7
4
2
10
6
9
10
7
10
6
5
1
1
10
8
6
3
3
10
10
10
10
10
8
10
5
3
0
361
%gap
0.000
0.000
0.017
0.004
0.003
0.000
0.100
0.000
0.033
0.000
0.078
0.058
0.038
0.044
0.045
0.000
0.000
0.100
0.100
0.067
0.020
0.000
0.020
0.026
0.035
0.000
0.400
0.050
0.000
0.100
0.000
0.038
0.037
0.051
0.037
0.000
0.017
0.025
0.031
0.029
0.000
0.000
0.000
0.000
0.000
0.045
0.000
0.053
0.056
0.066
0.036
UB
71
134
200
275
317
10
20
25
32
39
54
96
140
194
228
10
19
25
33
39
66
119
182
247
288
10
19
22
30
35
55
113
161
233
277
58
113
162
228
281
143
278
437
577
695
44
74
102
130
162
7302
TL=600
#opt
10
10
7
9
10
10
9
10
9
10
7
6
6
3
4
10
10
8
7
8
9
10
7
4
2
10
6
9
10
7
10
6
5
1
3
10
9
7
5
3
10
10
10
10
10
8
10
6
3
1
374
67
%gap
0.000
0.000
0.017
0.004
0.000
0.000
0.100
0.000
0.033
0.000
0.078
0.058
0.032
0.039
0.035
0.000
0.000
0.100
0.100
0.067
0.020
0.000
0.020
0.026
0.035
0.000
0.400
0.050
0.000
0.100
0.000
0.038
0.032
0.041
0.030
0.000
0.009
0.018
0.022
0.025
0.000
0.000
0.000
0.000
0.000
0.045
0.000
0.045
0.056
0.059
0.035
UB
71
134
200
275
317
10
20
25
32
39
54
96
140
194
228
10
19
25
33
39
66
119
181
247
288
10
19
22
30
35
55
113
159
232
277
58
113
162
227
280
143
278
437
577
695
44
74
102
130
161
7295
TL=1,800
#opt %gap
10 0.000
10 0.000
7 0.017
9 0.004
10 0.000
10 0.000
9 0.100
10 0.000
9 0.033
10 0.000
7 0.078
6 0.058
6 0.032
3 0.039
4 0.035
10 0.000
10 0.000
8 0.100
7 0.100
8 0.067
9 0.020
10 0.000
8 0.013
4 0.026
2 0.035
10 0.000
6 0.400
9 0.050
10 0.000
7 0.100
10 0.000
6 0.038
7 0.019
2 0.037
3 0.030
10 0.000
9 0.009
7 0.018
6 0.018
4 0.022
10 0.000
10 0.000
10 0.000
10 0.000
10 0.000
8 0.045
10 0.000
6 0.045
3 0.056
2 0.052
381 0.034
Table 4.1: Results on 2BP instances from the literature for the basic algorithm.
68
Chapter 4 Partial enumeration algorithms for 2BP|O|G
class
n
20
40
1
60
80
100
20
40
2
60
80
100
20
40
3
60
80
100
20
40
4
60
80
100
20
40
5
60
80
100
20
40
6
60
80
100
20
40
7
60
80
100
20
40
8
60
80
100
20
40
9
60
80
100
20
40
10
60
80
100
Global
LB
71
134
197
274
317
10
19
25
31
39
51
92
136
187
221
10
19
23
30
37
65
119
179
241
279
10
15
21
30
32
55
109
156
224
269
58
112
159
223
274
143
278
437
577
695
42
74
98
123
153
7173
UB
71
134
200
275
317
10
20
25
32
39
54
96
140
190
226
10
19
25
33
39
66
119
181
247
288
10
19
22
30
35
55
113
159
232
277
58
113
162
227
281
143
278
437
577
695
44
74
102
130
160
7289
TL=60
#opt
10
10
7
9
10
10
9
10
9
10
7
6
6
7
5
10
10
8
7
8
9
10
8
4
2
10
6
9
10
7
10
6
7
2
3
10
9
7
6
3
10
10
10
10
10
8
10
6
3
3
386
%gap
0.000
0.000
0.017
0.004
0.000
0.000
0.100
0.000
0.033
0.000
0.078
0.058
0.032
0.017
0.024
0.000
0.000
0.100
0.100
0.067
0.020
0.000
0.013
0.026
0.035
0.000
0.400
0.050
0.000
0.100
0.000
0.038
0.019
0.037
0.030
0.000
0.009
0.018
0.018
0.025
0.000
0.000
0.000
0.000
0.000
0.045
0.000
0.045
0.056
0.046
0.033
UB
71
134
200
275
317
10
20
25
32
39
54
96
140
190
226
10
19
25
33
39
66
119
181
247
288
10
19
22
30
35
55
113
159
232
276
58
113
162
227
280
143
278
437
577
695
44
74
102
130
159
7286
TL=600
#opt
10
10
7
9
10
10
9
10
9
10
7
6
6
7
5
10
10
8
7
8
9
10
8
4
2
10
6
9
10
7
10
6
7
2
4
10
9
7
6
4
10
10
10
10
10
8
10
6
3
4
389
%gap
0.000
0.000
0.017
0.004
0.000
0.000
0.100
0.000
0.033
0.000
0.078
0.058
0.032
0.017
0.024
0.000
0.000
0.100
0.100
0.067
0.020
0.000
0.013
0.026
0.035
0.000
0.400
0.050
0.000
0.100
0.000
0.038
0.019
0.037
0.026
0.000
0.009
0.018
0.018
0.022
0.000
0.000
0.000
0.000
0.000
0.045
0.000
0.045
0.056
0.040
0.033
UB
71
134
200
275
317
10
20
25
32
39
54
96
140
190
225
10
19
25
33
39
66
119
181
247
286
10
19
22
30
35
55
113
159
232
275
58
113
162
226
280
143
278
437
577
695
44
74
102
130
159
7281
TL=1,800
#opt %gap
10 0.000
10 0.000
7 0.017
9 0.004
10 0.000
10 0.000
9 0.100
10 0.000
9 0.033
10 0.000
7 0.078
6 0.058
6 0.032
7 0.017
6 0.019
10 0.000
10 0.000
8 0.100
7 0.100
8 0.067
9 0.020
10 0.000
8 0.013
4 0.026
4 0.027
10 0.000
6 0.400
9 0.050
10 0.000
7 0.100
10 0.000
6 0.038
7 0.019
2 0.037
4 0.022
10 0.000
9 0.009
7 0.018
7 0.014
4 0.022
10 0.000
10 0.000
10 0.000
10 0.000
10 0.000
8 0.045
10 0.000
6 0.045
3 0.056
4 0.040
393 0.033
Table 4.2: Results on 2BP instances from the literature for the enhanced algorithm
with N1 = 500, N2 = 500 and δ = 0.1.
Chapter 4 Partial enumeration algorithms for 2BP|O|G
69
bounds (or optimal values) for the relaxation of the problem in which guillotine constraint is not imposed, these results show that even the basic version of the algorithm
is quite effective. Results are even better for the enhanced algorithm, which is able
to solve to optimality 386 instances in the 60 seconds time limit, and has an average
percentage error approximatively equal to 3.3%. We note that these figures are slightly
better than the results obtained by the basic algorithm in the 30-minutes time limit;
thus, it is not surprising that only marginal improvements can be obtained over these
solutions with longer time limits. In particular, increasing the time limit to 1,800 CPU
seconds leads to saving 8 bins and to 7 additional optimal solutions.
In order to evaluate the quality of the results obtained we report in Table 4.3 the
information on the overall number of bins required in the best known solutions in the
literature (taken from [62]) for problem 2BP|O|F. We want to stress again that this
information is reported for reference only, to compare the performance of our heuristic
with those of the state-of-the-art algorithms for a less constrained problem in which
guillotine constraints are not imposed. This comparison shows that the global number
of bins used over the 500 instances by algorithm ENH is about 0.5% more than the same
figure for the problem in which guillotine constraint is not imposed (7281 vs 7241).
This confirms that a very marginal increase in the solution value has to be incurred to
impose the guillotine constraint, and makes the algorithm’s performance comparable
to those of the best heuristic algorithms proposed in the literature for 2BP|O|F.
class
1
2
3
4
5
6
7
8
9
10
Global
2BP|O|F
LB
UB
993
997
124
124
687
696
119
124
883
892
108
112
813
827
826
835
2130 2130
490
504
7173 7241
UB
997
126
705
126
899
116
834
839
2130
509
7281
ENH
#opt
46
48
32
43
35
42
29
37
50
31
393
%gap
0.004
0.027
0.041
0.053
0.017
0.110
0.023
0.013
0.000
0.037
0.033
Table 4.3: Comparison between guillotine and non-guillotine heuristics. Time limit
= 1,800 CPU seconds.
4.5.
Conclusions
In this chapter we considered the orthogonal Two-Dimensional bin packing problem in
which items cannot be rotated and guillotine constraints are imposed. For this problem,
denoted as 2BP|O|G, we developed a heuristic algorithm based on partial enumeration,
possibly enhanced so as to reduce the search space. An extensive computational analysis on a large set of instances from the literature shows that the algorithm is able to
70
Chapter 4 Partial enumeration algorithms for 2BP|O|G
solve more than 78% of the problems, with an average gap of 3.3%, thus confirming the
viability of the approach. As these performance numbers are computed with respect
to some lower bound values for the relaxed problem in which guillotine constraints are
not imposed (i.e., 2BP|O|F), future research direction will be devoted in developing
fast lower bounding techniques for 2BP|O|G.
Bibliography
[1] B. S. Baker, E. G. Coffman, Jr, and R. L. Rivest. Orthogonal packings in two
dimensions. SIAM Journal on Computing, 9(4):846–855, 1980.
[2] N. Bansal, A. Caprara, and M. Sviridenko. Improved approximation algorithms
for multidimensional bin packing problems. In Foundations of Computer Science,
2006. FOCS’06. 47th Annual IEEE Symposium on, pages 697–708. IEEE, 2006.
[3] N. Bansal and M. Sviridenko. New approximability and inapproximability results
for 2-dimensional bin packing. In Proceedings of the fifteenth annual ACM-SIAM
symposium on Discrete algorithms, pages 196–203. Society for Industrial and Applied Mathematics, 2004.
[4] J. E. Beasley. An exact two-dimensional non-guillotine cutting tree search procedure. Operations Research, 33(1):49–64, 1985.
[5] J. Berkey and P. Wang. Two-dimensional finite bin-packing algorithms. Journal
of the Operational Research Society, 38:423–429, 1987.
[6] A. Bettinelli, A. Ceselli, and G. Righini. A branch-and-price algorithm for the twodimensional level strip packing problem. 4OR: A Quarterly Journal of Operations
Research, 6(4):361–374, 2008.
[7] Marco A Boschetti and Aristide Mingozzi. The two-dimensional finite bin packing
problem. part i: New lower bounds for the oriented case. Quarterly Journal of the
Belgian, French and Italian Operations Research Societies, 1(1):27–42, 2003.
[8] Marco A Boschetti and Aristide Mingozzi. The two-dimensional finite bin packing
problem. part ii: New lower and upper bounds. Quarterly Journal of the Belgian,
French and Italian Operations Research Societies, 1(2):135–147, 2003.
[9] A. Caprara. Packing 2-dimensional bins in harmony. In Foundations of Computer
Science, 2002. Proceedings. The 43rd Annual IEEE Symposium on, pages 490–499.
IEEE, 2002.
[10] A. Caprara, A. Lodi, and M. Monaci. An approximation scheme for the two-stage,
two-dimensional bin packing problem. In Integer Programming and Combinatorial
Optimization, pages 315–328. Springer Berlin Heidelberg, 2002.
71
72
BIBLIOGRAPHY
[11] A. Caprara and M. Monaci. On the two-dimensional knapsack problem. Operations Research Letters, 32(1):5–14, 2004.
[12] A. Caprara and M. Monaci. Bidimensional packing by bilinear programming.
Mathematical Programming, 118(1):75–108, 2009.
[13] C. Charalambous and K. Fleszar. A constructive bin-oriented heuristic for the twodimensional bin packing problem with guillotine cuts. Computers & Operations
Research, 38:1443–1451, 2011.
[14] B. Chazelle. The bottomn-left bin-packing heuristic: An efficient implementation.
Computers, IEEE Transactions on, 100(8):697–707, 1983.
[15] N. Christofides and E. Hadjiconstantinou. An exact algorithm for orthogonal 2-d
cutting problems using guillotine cuts. European Journal of Operational Research,
83(1):21–38, 1995.
[16] F.K.R. Chung, M.R. Garey, and D.S. Johnson. On packing two-dimensional bins.
SIAM Journal on Algebraic Discrete Methods, 3(1):66–76, 1982.
[17] E. G. Coffman, Jr, M. R. Garey, D. S. Johnson, and R. E. Tarjan. Performance
bounds for level-oriented two-dimensional packing algorithms. SIAM Journal on
Computing, 9(4):808–826, 1980.
[18] J. Csirik and G. Woeginger. On-line packing and covering problems. In Amos
Fiat and GerhardJ. Woeginger, editors, Online Algorithms, volume 1442 of Lecture
Notes in Computer Science, pages 147–177. Springer Berlin Heidelberg, 1998.
[19] X. Chen D. Simchi-Levi and J. Bramel. The logic of logistics: theory, algorithms,
and applications for logistics and supply chain management. Springer, 2007.
[20] M. Dell’Amico and S. Martello. Optimal scheduling of tasks on identical parallel
processors. ORSA Journal on Computing, 7(2):191–200, 1995.
[21] M. Dolatabadi, A. Lodi, and M. Monaci. Exact algorithms for the two-dimensional
guillotine knapsack. Computers & Operations Research, 39:48–53, 2012.
[22] O. Faroe, D. Pisinger, and M. Zachariasen. Guided local search for the threedimensional bin packing problem. Department of Computer Science, University of
Copenhagen, 1999.
[23] S.P. Fekete and J. Schepers. New classes of lower bounds for bin packing problems. In Integer Programming and Combinatorial Optimization, pages 257–270.
Springer, 1998.
[24] S.P. Fekete and J. Schepers. A combinatorial characterization of higherdimensional orthogonal packing. Mathematics of Operations Research, 29(2):353–
368, 2004.
BIBLIOGRAPHY
73
[25] S.P. Fekete and J. Schepers. A general framework for bounds for higherdimensional orthogonal packing problems. Mathematical Methods of Operations
Research, 60(2):311–329, 2004.
[26] S.P. Fekete, J. Schepers, and J. C. Van der Veen. An exact algorithm for higherdimensional orthogonal packing. Operations Research, 55(3):569–587, 2007.
[27] K. Fleszar. Three insertion heuristics and a justification improvement heuristic
for two-dimensional bin packing with guillotine cuts. Computers & Operations
Research, 40:463–474, 2013.
[28] J.B. Frenk and G.G. Galambos. Hybrid next-fit algorithm for the two-dimensional
rectangle bin-packing problem. Computing, 39:201–217, 1987.
[29] A. Freund and J. S. Naor. Approximating the advertisement placement problem.
Journal of Scheduling, 7(5):365–374, 2004.
[30] P. C. Gilmore and R. E. Gomory. A linear programming approach to the cutting
stock problem. Operations Research, 9:849–859, 1961.
[31] P. C. Gilmore and R. E. Gomory. A linear programming approach to the cutting
stock problem - part II. Operations Research, 11:863–888, 1963.
[32] P.C. Gilmore and R.E. Gomory. Multistage cutting problems of two and more
dimensions. Operations Research, 13:94–119, 1965.
[33] D.E. Goldberg. Genetic algorithms in search, optimization, and machine learning.
Number 2. Addison-Wesley, Reading, MA, 1989.
[34] E. Hadjiconstantinou and N. Christofides. An exact algorithm for general, orthogonal, two-dimensional knapsack problems. European Journal of Operational
Research, 83(1):39–56, 1995.
[35] R. Harren. Two-dimensional packing problems. PhD thesis, Universität des Saarlandes, Germany, 2010.
[36] R. Harren and R. van Stee. An absolute 2-approximation algorithm for the twodimensional bin packing. submitted for publication.
[37] R. Harren and R. van Stee. Absolute approximation ratios for packing rectangles
into bins. Journal of Scheduling, 15(1):63–75, 2012.
[38] J. Holland. H., 1975, adaptation in natural and artificial systems. Ann Arbor,
MI: University of Michigan Press, 1975.
[39] M. Iori, S. Martello, and M. Monaci. Metaheuristic algorithms for the strip packing
problem. Applied Optimization, 78:159–180, 2003.
74
BIBLIOGRAPHY
[40] D.S. Johnson. Near-optimal bin packing algorithms. PhD thesis, Massachusetts
Institute of Technology, 1973.
[41] D.S. Johnson, A. Demers, J.D. Ullman, M.R. Garey, and R.L. Graham. Worstcase performance bounds for simple one-dimensional packing algorithms. SIAM
Journal on Computing, 3(4):299–325, 1974.
[42] J. Jylänki.
A thousand ways to pack the bin - a practical approach to two-dimensional rectangle bin packing. Technical report, 2010.
http://clb.demon.fi/files/RectangleBinPack.pdf.
[43] C. Kenyon and E. Rémila. A near-optimal solution to a two-dimensional cutting
stock problem. Math. Oper. Res., 25(4):645–656, 2000.
[44] S. Kirkpatrick, C.D. Gelatt, M.P. Vecchi, et al. Optimization by simmulated
annealing. science, 220(4598):671–680, 1983.
[45] K. Lagus, I. Karanta, and J. Ylä-Jääski. Paginating the generalized newspaper:
A comparison of simulated annealing and a heuristic method. In Parallel Problem
Solving from Nature — PPSN IV, volume 1141 of Lecture Notes in Computer
Science, pages 594–603. Springer, 1996.
[46] C.C. Lee and D.T. Lee. A simple on-line bin-packing algorithm. Journal of the
ACM (JACM), 32(3):562–572, 1985.
[47] K. Li and K. H. Cheng. Static job scheduling in partitionable mesh connected
systems. Journal of Parallel and Distributed Computing, 10(2):152–159, 1990.
[48] D.S. Liu, K.C. Tan, S.Y. Huang, C.K. Goh, and W.K. Ho. On solving multiobjective bin packing problems using evolutionary particle swarm optimization.
European Journal of Operational Research, 190(2):357 – 382, 2008.
[49] A. Lodi. Algorithms for Two-Dimensional Bin Packing and Assignment Problems.
PhD thesis, University of Bologna, Italy, 2000.
[50] A. Lodi, S. Martello, and M. Monaci. Two-dimensional packing problems: A
survey. European Journal of Operational Research, 141(2):241–252, 2002.
[51] A. Lodi, S. Martello, M. Monaci, C. Cicconetti, L. Lenzini, E. Mingozzi, C. Eklund, and J. Moilanen. Efficient two-dimensional packing algorithms for mobile
wimax. Management Science, 57:2130–2144, 2011.
[52] A. Lodi, S. Martello, and D. Vigo. Approximation algorithms for the oriented
two-dimensional bin packing problem. European Journal of Operational Research,
112:158–166, 1999.
[53] A. Lodi, S. Martello, and D. Vigo. Heuristics and metaheuristic approaches for a
class of two-dimensional bin packing problems. INFORMS Journal on Computing,
11:345–357, 1999.
BIBLIOGRAPHY
75
[54] A. Lodi, S. Martello, and D. Vigo. Neighborhood search algorithm for the guillotine non-oriented two-dimensional bin packing problem. In Meta-Heuristics, pages
125–139. Springer US, 1999.
[55] A. Lodi, S. Martello, and D. Vigo. Recent advances on two-dimensional bin
packing problems. Discrete Applied Mathematics, 123(1):379–396, 2002.
[56] A. Lodi, S. Martello, and D. Vigo. Models and bounds for two-dimensional level
packing problems. Journal of Combinatorial Optimization, 8(3):363–379, 2004.
[57] A. Lodi, M. Monaci, and E. Pietrobuoni. Partial enumeration algorithms for
two-dimensional bin packing problem with guillotine constraints. submitted for
publication. 2014.
[58] M. Lübbecke and J. Desrosiers. Selected topics in column generation. Operations
Research, 53(6):1007–1023, 2005.
[59] G.S. Lueker. Bin packing with items uniformly distributed over intervals [a,b].
In Foundations of Computer Science, 1983., 24th Annual Symposium on, pages
289–297, Nov 1983.
[60] S. Martello, M. Monaci, and D. Vigo. An exact approach to the strip-packing
problem. INFORMS Journal on Computing, 15(3):310–319, 2003.
[61] S. Martello and D. Vigo. Exact solution of the two-dimensional finite bin packing
problem. Management Science, 44:388–399, 1998.
[62] M. Monaci and P. Toth. A set-covering based heuristic approach for bin-packing
problems. INFORMS Journal on Computing, 18:71–85, 2006.
[63] C. Kenyon N. Bansal, J.R. Correa and M. Sviridenko. Bin packing in multiple
dimensions: inapproximability results and approximation schemes. Mathematics
of Operations Research, 31(1):31–49, 2006.
[64] D. Pisinger and M. Sigurd. Using decomposition techniques and constraint programming for solving the two-dimensional bin-packing problem. INFORMS Journal on Computing, 19:36–51, 2007.
[65] S. Polyakovsky and R. M’Hallah. An agent-based approach to the two-dimensional
guillotine bin packing problem. European Journal of Operational Research,
192:767–781, 2009.
[66] J. Puchinger and G.R. Raidl. Models and algorithms for three-stage twodimensional bin packing. European Journal of Operational Research, 183:1304–
1327, 2007.
[67] I. Schiermeyer. Reverse-fit: A 2-optimal algorithm for packing rectangles. In
Proceedings of the Second Annual European Symposium on Algorithms, ESA ’94,
pages 290–299, London, UK, UK, 1994. Springer-Verlag.
76
BIBLIOGRAPHY
[68] D.D. Sleator. A 2.5 times optimal algorithm for packing in two dimensions. Information Processing Letters, 10(1):37–40, 1980.
[69] A. Soke and Z. Bingul. Hybrid genetic algorithm and simulated annealing for
two-dimensional non-guillotine rectangular packing problems. Engineering Applications of Artificial Intelligence, 19(5):557 – 567, 2006.
[70] A. Steinberg. A strip-packing algorithm with absolute performance bound 2.
SIAM J. Comput., 26(2):401–409, 1997.
[71] P. Toth and S. Martello. Knapsack problems: Algorithms and computer implementations. Discrete Mathematics and Optimization. Wiley, 1990.
[72] R. van Stee. An approximation algorithm for square packing. Operations Research
Letters, 32(6):535–539, 2004.
[73] F. Vanderbeck. A nested decomposition approach to a 3-stage 2-dimensional
cutting stock problem. Management Science, 47:864–879, 2001.
[74] G. Zhang. A 3-approximation algorithm for two-dimensional bin packing. Operations Research Letters, 33(2):121 – 126, 2005.
Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Related manuals

Download PDF

advertisement