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.

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

Download PDF

advertisement