A Binary Search Heuristic Algorithm Based on ... - Semantic Scholar

INFORMS Journal on Computing Vol. 25, No. 2, Spring 2013, pp. 332–345 ISSN 1091-9856 (print) ISSN 1526-5528 (online)

http://dx.doi.org/10.1287/ijoc.1120.0505 © 2013 INFORMS

A Binary Search Heuristic Algorithm Based on Randomized Local Search for the Rectangular Strip-Packing Problem Defu Zhang Department of Computer Science, Xiamen University, Xiamen, 361005, China, [email protected]

Lijun Wei, Stephen C. H. Leung Department of Management Sciences, City University of Hong Kong, Kowloon, Hong Kong {[email protected], [email protected]}

Qingshan Chen Department of Computer Science, Xiamen University, Xiamen, 361005, China, [email protected]

T

his paper presents a binary search heuristic algorithm for the rectangular strip-packing problem. The problem is to pack a number of rectangles into a sheet of given width and infinite height so as to minimize the required height. We first transform this optimization problem into a decision problem. A least-waste-first strategy and a minimal-inflexion-first strategy are proposed to solve the related decision problem. Lastly, we develop a binary search heuristic algorithm based on randomized local search to solve the original optimization problem. The computational results on six classes of benchmark problems have shown that the presented algorithm can find better solutions within a reasonable time than the published best heuristic algorithms for most zero-waste instances. In particular, the presented algorithm is proved to be the dominant algorithm for large zero-waste instances. Key words: rectangular strip packing; heuristic; local search; binary search History: Accepted by Michel Gendreau, (former) Area Editor for Heuristic Search and Learning; received January 2007; revised December 2007, October 2008, February 2010; accepted September 2011. Published online in Articles in Advance June 6, 2012.

1.

Introduction

and then applies BLF + metaheuristic for the remaining rectangles. Martello et al. (2003) gave an exact approach to the strip-packing problem, and a new relaxation, that produces good lower bounds and provides information to obtain effective heuristic algorithms, was used in a branch-and-bound algorithm. The less flexibility first principle was introduced by Wu et al. (2002) to determine the packing rules. Zhang et al. (2005, 2006) proposed a new heuristic recursive algorithm and a metaheuristic algorithm based on the recursive strategy and the simulated annealing algorithm. Huang et al. (2007) presented a very effective heuristic algorithm, in which two important concepts, namely, the corner-occupying action and caving degree, were introduced to guide the packing. Cui et al. (2008) presented a new heuristic recursive algorithm based on a recursive structure combined with branch-and-bound techniques. Hopper and Turton (2001) empirically investigated metaheuristic and heuristic algorithms for 2D packing problems that have been developed for different variants of the strip-packing problems. Artificial neural networks were introduced by Dagli and Poshyanonda (1997) to

The packing problem is faced in many industries, with different applications incorporating different constraints and objectives. For example, in shipping encasement, objects of different sizes have to be packed as many as possible into a large container. In newspapers, advertisements and articles have to be arranged in individual pages in the most efficient manner. Lodi et al. (2002), Dowsland and Dowsland (1992), and Pisinger (2002) gave more extensive and detailed descriptions of the packing problem. In this paper, we consider the rectangular strip-packing problem. Various heuristic algorithms based on different methodologies have been presented for solving this problem. The bottom-left (BL) and bottom-left fill (BLF) methods (Baker et al. 1980 and Chazelle 1983) are the most famous heuristic approaches. A genetic algorithm based on BL is presented in Liu and Teng (1999) which uses an improved BL heuristic. Burke et al. (2004) suggested a different construction method (BF). Later, Burke et al. (2009) improved their heuristic by adding a metaheuristic phase that first uses the best-fit heuristic to pack some rectangles 332

Zhang et al.: Randomized Local Search for the Rectangular Strip Packing Problem

333

INFORMS Journal on Computing 25(2), pp. 332–345, © 2013 INFORMS

solve the packing problem. Kröger (1995) presented a genetic approach for guillotinable bin packing problems. Bortfeldt (2006) presented a genetic algorithm that works directly on the layout solutions and does not have any encoding of the solutions (SPGAL). Alvarez-Valdes et al. (2008) presented a greedy randomized adaptive search procedure (GRASP) for the strip-packing problem. SPGAL, BLF + metaheuristic, and GRASP are three of the current best algorithms to solve the strip-packing problem. Hifi (1999) and Hifi and M’Hallah (2003) proposed a hybrid algorithm for the two-dimensional layout problem. Most algorithms mentioned above have similar processes: a construction heuristic algorithm is first used to obtain an initial solution, and then it is combined with a local search or metaheuristic to obtain a desirable solution. The idea of using local search to alter the order of the rectangles, for example, using a swap neighborhood by Oliveira and Ferreira (1993) and Zhang et al. (2006), is often used to improve the solution. Generally these algorithms perform reasonably well, though intuitively most algorithms have some drawbacks. For example, some algorithms cannot make full use of information for controlling wasted space. Some algorithms are more complicated because they have to first set some parameters by learning some instances to obtain a desirable solution. The idea of transforming the problem into a decision problem and then searching the space with the appropriate height and the fixed width is useful (Oliviera and Ferreira 1993 and Dowsland 1993), and it can be used to efficiently solve the rectangular strippacking problem. In this paper, we first transform this optimization problem into a decision problem and then present a least-waste-first strategy and a minimal-inflexion-first strategy, which evaluates the positions of the rectangles to solve the decision problem. Lastly we introduce a binary search heuristic algorithm (BSHA) based on randomized local search to solve the original strip-packing problem. The computational results on six classes of benchmark problems show that BSHA can find better solutions within a reasonable time than the published best heuristic algorithms. In particular, the presented algorithm was proved to be the dominant algorithm for large packing problems.

2.

describe a rectangular packing problem (RPP), the aim of which is to maximize the area of rectangles packed into a sheet with fixed dimensions, and then use the rectangular packing problem to describe the rectangular strip-packing problem (RSPP). 2.1. Rectangular Packing Problem Given a rectangular sheet B with width W and height H , and a set R of n rectangles with each rectangle Ri of width wi and height hi 1 ≤ i ≤ n, the aim of the RPP is to find a packing that maximizes the total area of the rectangles packed into the sheet. The packing must satisfy the following constraints: each edge of the packed rectangles should be parallel to an edge of the sheet, which is also called orthogonal packing; and any two packed rectangles should not overlap each other. It is to be noted that we have assumed that the rectangles can be rotated by 90 . To state this problem more formally, place the bottom left of the sheet at origin (0 0) of the two-dimensional Cartesian coordinate system and let its four sides be parallel to either the x- or y-axis (Figure 1), thereby allowing the rectangle to rotate 90 , which means that an edge of the packed rectangle can be parallel to either the x-axis or the y-axis. For example, in Figure 1, two arrangements of rectangle Ri are feasible. Let fi 1 ≤ i ≤ n denote whether rectangle Ri has been packed into the sheet or not, if yes then fi = 1, otherwise fi = 0. For every rectangle Ri packed into the sheet, let (xli yli ) denote the coordinates of its bottom-left corner, and (xri yri ) denote the coordinates of its top-right corner. The mathematical formulation of the problem can be described as follows: max

n

fi wi hi

i=1

subject to

fi = 0 ∨ 0 ≤ xli < xri ≤ W ∧ 0 ≤ yli < yri ≤ H

i = 1 2 n

y

H

Problem Description

This paper is concerned with the rectangular strippacking problem which belongs to the subtype RF (the rectangles may be rotated by 90 (R) and no guillotine cutting is required (F)) as described by Lodi et al. (1999) and Bortfeldt (2006). According to an improved typology of cutting and packing problems, this problem belongs to an open dimension problem (Wäscher et al. 2007). In this section, we first

Ri 0 Figure 1

Ri W

The Coordinate System

x

(1)


334


fi = 0 ∨ xri − xli = wi ∧ yri − yli = hi i = 1 2 n

5

y

· ∨xri − xli = hi ∧ yri − yli = wi

1

(2)

Envelope

fi = 0∨fj = 0∨xli ≥ xrj ∨xlj ≥ xri ∨yli ≥ yrj ∨ylj ≥ yri i j = 1 2 n i = j fi ∈ 0 1

i = 1 2 n

(3)

where Equation (1) implies that each rectangle is placed within the confines of the sheet; (2) implies that the rectangles to be packed are rotatable; (3) implies that any two packed rectangles cannot overlap each other; and (4) states whether each rectangle can be packed into the sheet or not. 2.2. Rectangular Strip-Packing Problem Given a rectangular sheet B with width W and infinite height, a set R of n rectangles with each rectangle Ri of width wi and height hi 1 ≤ i ≤ n, the aim of the RSPP is to pack all the rectangles into the sheet so as to minimize the used height of the sheet. The packing must satisfy the constraints of the RPP, except that the height of the sheet is not fixed. We use the RPP to describe the RSPP formally: find the minimum height of the sheet such that the corresponding RPP can find a packing that packs all the rectangles into the sheet.

3.

H

2

(4)

Random Local Search Algorithm for the RPP

In this section, we first present a least-waste-first strategy based on the way of finding positions to pack rectangles, and then we develop a random local search algorithm based on the least-waste strategy for the RPP. Let I denote the set of the rectangles packed into the sheet, the unpacked rectangles may be packed only at position p such that these rectangles must be packed above or to the right of p, and cannot overstep the border of the sheet. More formally, the unpacked rectangles can be packed only at the positions contained in the set:

3 0 Figure 2

W

4

x

Inflexions

then determines corner points to reduce the number of positions. We only consider the inflexions where the edge of the envelope changes from vertical to horizontal (black points in Figure 2). An inflexion is similar to the concept of a corner point defined in references (Martello et al. 2000, 2003). We call these inflexions (except one inflexion at the top-right corner of the sheet) feasible positions. The unpacked rectangles are considered for packing at these feasible positions. In Figure 2, inflexions (except inflexion 5) 1, 2, 3, and 4 are feasible positions. To avoid invalid search, we can further reduce the number of feasible positions in the following way: If the gap between a feasible position and the border of the sheet is less than the smallest edge of the unpacked rectangles, we think this position is a bad position because none of the unpacked rectangles can be packed at this position. In any configuration, if there exist some bad positions, we can discard them and make some changes to the envelope. The changed envelope is shown in Figure 3 (the grey area is discarded). For example, in Figure 3, if both gap l1 and gap l2 are smaller than the smallest y

5

l1 1 Envelope

SI = x y ∀ Ri ∈ I x ≥ xri or y ≥ yri and x ≤ W and y ≤ H

Figure 2 shows the feasible area that is enclosed by the dotted line, where the area is called an envelope. The envelope contains the positions belonging to SI, and the unpacked rectangles can be packed at any position within the envelope. Obviously, the envelope contains too many infeasible positions, so we can develop the idea of finding a position (Martello et al. 2000) that first finds extreme items and

H

2 3

0

Figure 3

W

The Changed Envelope

4

l2

x

Zhang et al.: Randomized Local Search for the Rectangular Strip Packing Problem INFORMS Journal on Computing 25(2), pp. 332–345, © 2013 INFORMS

edge of the unpacked rectangles, we discard bad positions 1 and 4, so the current feasible positions only have 2 and 3. It is noted that to determine whether an unpacked rectangle can be packed at a feasible position or not, we just need to check if the rectangle oversteps the border of the sheet. If some rectangles can be packed into current feasible positions 2 and 3 (see Figure 4), the problem is to decide which rectangle will be packed at what position. When a rectangle is packed at one of the current feasible positions, the envelope will be reduced. Furthermore, the area cut down from the envelope can be larger than that of the corresponding packed rectangle. In this case, some area is wasted and cannot be reused. For example, in Figure 4, when rectangle Ri is packed at position 3, it results in the bias area being wasted. This shows that packing Ri at position 3 is not a good choice. To obtain a better choice, we can construct the following least-wastefirst strategy: Let the set of the current feasible positions be P and the set of the unpacked rectangles be U , given a combination Ri p b, where Ri ∈ U , p ∈ P , b ∈ 0 1, b = 0 means the longest edge of rectangle Ri is parallel to the x-axis, and b = 1 means the longest edge of the rectangle is parallel to the y-axis. Then we can calculate the wasted area ARi p b by packing Ri at current feasible positions p according to the value of b. Obviously, we hope to minimize the wasted area to maximize the total area available to pack the rectangles into the sheet. In addition, the rectangles with smaller areas should be packed later so that space is available for large rectangles. So we should consider both the size of the rectangle and the wasted area to select a good combination. In detail, we should select the unpacked rectangle r that will be packed at the current feasible position q such that the corresponding ratio Ar q c/sr is minimal. Namely, Ar q c/sr = minRi ∈U p∈P b∈ 0 1 ARi p b/si , where si denotes the area of rectangle i. It must be noted y l1 Envelope 6

H

Ri

2 3

7 0

W l2

Figure 4

The Wasted Area

x

335

that the wasted area is calculated after we discard the bad positions because discarding the bad positions can reduce the number of feasible positions and simplify the calculation of the wasted area. The idea of using information based on the wasted areas that cannot be used by other rectangles has also been applied by Dowsland et al. (2006). However, the definition of the wasted area is different and is applied in a different way. Dowsland et al. (2006) think that any gaps left “behind” the current packing can be identified as waste. The waste is used to define the bound applicable to tree search. In this paper, the wasted area is calculated by Ar q c and is used to select a rectangle to be packed. In addition, given a combination Ri p b, where Ri ∈ U p ∈ P b ∈ 0 1, we can calculate the corresponding ratio. It is possible that several combinations have the same minimal ratio in the current configuration. So we must consider which combination should be selected when the number of such combinations is more than one. We know that an envelope with a minimal inflexion will contain less wasted area. Inspired by the experience in daily life, we should make the envelope with minimal inflexion. So we should develop a way to measure the change of the inflexion for an envelope. We can observe that each feasible position is formed by a horizontal and a vertical segment. Given a combination Ri p 1, when rectangle Ri is packed at position p, if the width of the rectangle is equal to the horizontal segment and the height of the rectangle is equal to the vertical segment, we think this combination is a good combination because the resulting envelope has less inflexion. We use a variable inflexion (IN) to evaluate such combinations. For a combination Ri p 1, if the width of the rectangle is equal to the horizontal segment and the height of the rectangle is equal to the vertical segment, IN of this combination will be 2; if the width of the rectangle is equal to the horizontal segment or the height of the rectangle is equal to the vertical segment, IN of this combination will be 1; otherwise IN will be 0. Obviously, IN = 2 means the combination can decrease one inflexion, and it is a better combination. IN = 1 means the combination does not increase the number of inflexions, and it may also be a good combination. IN = 0 means the combination may increase one inflexion, and that makes it become a bad combination. So we can construct a minimal-inflexion-first strategy as follows: select a combination with a larger IN value when the corresponding ratio of several combinations is the same. For example, in Figure 5, the value of IN for combination Ri 2 1 is 2, the value of IN for combination Rj 1 0 is 0, and the value of IN for combination


336


5

y 1

Rj

hj

wj

hi

Envelope

wi

wi

Ri hi

H

Ri

Rj

2 Rk

wk

hk

Rk

3 0

W Vertical segment

Figure 5

4

hj

hk

wj wk

x

Horizontal segment

The Calculation of Inflexions

Rk 3 0 is 1. Therefore we can describe the way of selecting a combination as follows: (a) Select combination r q c by the least-wastefirst strategy such that ratio Ar q c/sr is minimal; (b) If the number of such combinations with the same ratio is more than one, select the combination by the minimal-inflexion-first strategy such that IN is maximal; (c) If the number of such combinations with the same IN is more than one, select the first combination by the position order from left to right; (d) If the number of such combinations with the same position is more than one, select the first combination by the given rectangle sequence. Using the strategy of selecting a combination as described above, we can get the following heuristic algorithm: rpp-packing(R, n, W, H) I ← ; U ← R while U = do calculate the set P of all the feasible positions; use the method described above to select a combination r q c from U and P ; if the combination r q c does not exist, then U = ; else pack r at the position q according to the way of c I ← I ∪ r U ← U − r; return the total area of rectangles in I. Where R is the ordered set of rectangles, n is the number of rectangles in R, W is the width of the sheet, and H is the height. I is the set of the current packed rectangles, P denotes the set of all the feasible positions, and U denotes the set of the unpacked rectangles. In the procedure rpp-packing(R, n, W, H), we first let I be empty, and then execute the packing process until none of the unpacked rectangles can be

packed into the sheet. The total area of the packed rectangles is returned at the end. Since the result of the procedure rpp-packing(R, n, W, H) depends on the sequence of the rectangles in R, we import a randomized local search to improve the result. The randomized local search algorithm developed is described as follows: rls-rpp-packing(R, n, W, H, kmax, samemax, imax) sort the rectangles in descending order of their area in R; sortR ← R; best ← rpp-packing(R, n, W, H); same ← 0; for k = 1 to kmax do R ← sortR; for i = 1 to imax do select rectangle r and s from R randomly, swap the order of r and s in R; area ← rpp-packing(R, n, W, H); if area > best, then same ← 0, best ← area; if best = totarea, then return best; else swap the order of r and s in R, same ← same + 1; if same > samemax, then break; return best. Where the variable best is used to record the best result found so far, same is used to take count of the number of calls in which the result is not improved. The kmax is an upper bound on the number of times a local minimum is reached, sortR is used to save the sorted R, and totarea is the total area of rectangles in R. In the procedure rls-rpp-packing(R, n, W , H, kmax, samemax, imax), we first sort the rectangles by their area because the rectangles with maximum area should be packed first. To improve the result, we select two rectangles randomly (the size of the selected rectangles should be unequal), and swap their orders in R. Then call the procedure rpp-packing(R, n, W, H) to check whether the result is improved or not; if it is, we will accept the swap, otherwise undo it. If an optimal solution is found, we return it. If the result cannot be improved in the samemax calls, we believe a local minimum is reached and reset R to sortR. We stop the process when the number of times a local minimum has been reached is more than kmax.

4.

Binary Search Heuristic Algorithm (BSHA) for the RSPP

We now use the algorithm developed for the RPP to solve the RSPP. Clearly, the lower bound (LB) for the RSPP is the height where the area of the sheet is equal to the total area of the rectangles, namely, LB = ni=1 wi hi /W . To calculate an upper bound (UB),


337


we increase UB from LB until the procedure rpppacking(R, n, W, H) returns a value that is equal to the total area of rectangles in R. Lastly, we use binary search that repeatedly calls the procedure rlsrpp-packing(R, n, W, H, kmax, samemax, imax) to find a desirable height. The binary search heuristic algorithm developed is given as follows: bsh-rspp-packing(R1 n1 W 1 H5 sort the rectangles in descending order of their area in R; totarea ← 0; for i = 1 to R do if wi < hi , then swap(wi 1 hi 5; totarea ← totarea + wi × hi ; UB ← LB; while (rpp-packing(R, n, W, UB) 6= totarea) do UB ← UB + 1; k ← min41 + 4n − 15/1001 105; kmax ← 20/k, samemax ← 21000/k, imax ← 201000/k; head ← LB, tail ← UB; while (head < tail) do mid ← (head + tail)/2; if (rls-rpp-packing(R, n, W, mid, kmax, samemax, imax) = totarea), then tail ← mid; else head ← mid + 1; if (kmax > 10), then kmax ← kmax − 1; if (samemax > 11000), then samemax ← samemax − 100; if (imax > 101000), then imax ← imax − 11000; return head, where the variable totarea is the total area of rectangles in R; head, tail, and mid are variables used in the binary search; imax, kmax, samemax are the parameters used in the procedure rls-rpp-packing(R, n, W, H). In the procedure bsh-rspp-packing(R, n, W, H), we first sort the rectangles in R. For each rectangle Ri , if its width is less than its height, we swap its width with its height so that the width is not shorter than the height. We then calculate the lower bound LB and an upper bound UB, where LB and UB are integers. In the binary search, we first set head = LB and tail = UB, then repeat the following process until head is not less than tail: set mid = (head + tail)/2, check whether rls-rpp-packing(R, n, W, mid, kmax, imax, samemax) can find a packing that packs all the rectangles. If so, set tail = mid; otherwise set head = mid + 1. The variable head returned by bsh-rspp-packing(R, n, W, H) is the minimal height. It must be noted that the larger n is, the more call times are needed to call the procedure rls-rpp-packing(R, n, W, H). So we set kmax, samemax, and imax to the values that decrease with an increase of n, and we decrease the values of kmax, samemax, imax after each iteration of binary search. When the values of kmax, samemax, and imax are large, we note that the results are better, but a longer run time is

needed. To find a good result within an acceptable time, we set the values of kmax, samemax, and imax as above by experimentation. From the description of BSHA, we know the performance of BSHA depends on the filling rate of rls-rpp-packing(R, n, W , H 5. The higher the filling rate of BSHA is, the better the performance of BSHA is. In particular, if the filling rate is 100% and all the rectangles are packed, then BSHA is successfully stopped.

5.

Experimental Results

We implement the algorithm BSHA using C++ programming language. To compare the relative performance of BSHA with other published heuristic algorithms, we used six classes of test problems from the literature. Perhaps the most well-known problem class is the 21-rectangle packing instances proposed by Hopper and Turton (2001). Ramesh Babu and Ramesh Babu (1999) used a test instance to compare their GA with other GAs. Burke et al. (2004) randomly generated 13 problem instances. To extensively test the performance of BSHA for large instances, the extra-large instances proposed by Pinto and Oliviera (2005) are included. The size of the problem in these instances ranges from 50 to 15,000 rectangles. In most of the real-world problems, the optimal solutions involve some wasted areas, so it is very interesting and useful to test BSHA on these types of instances for verifying the performance of algorithms. Therefore, the non-zero-waste instances which make some parts of the sheet unused for the optimal packing are selected. Valenzuela and Wang (2001) provided floating-point data sets of both similarly dimensional rectangles (named “nice” data) and vastly differing dimensions (named “path” data). Each category has data with problem size ranging from 25 to 1,000 rectangles, where we transform these data into integer data by multiplying the original data by 10 and rounding to the nearest integer, so these data belong to non-zero-waste instances because of rounding. In addition, nine large non-zerowaste instances are generated by combining zerowaste instances with non-zero-waste instances (see the appendix). The optimal solutions of the former five instances are known, while the optimal solutions of the later four instances are unknown. All data sets and software are publicly available and can be downloaded from http://59.77.16.8/Download.aspx#p4 or http://dx.doi.org/10.1287/ijoc.1120.0505. Table 1 gives an overview of all the test data sets used in this paper. Where zero-waste = yes denotes that the corresponding data set belongs to zero-waste instances, zero-waste = no denotes the corresponding data set belongs to non-zero-waste instances. The variable class denotes the type of the data set,


338 Table 1


Test Data Sets Zero-waste ?

Class

TP

n

W

H∗

Hopper and Turton (2001)

Yes

C

Ramesh Babu and Ramesh Babu (1999) Burke et al. (2004) Pinto and Oliviera (2005) Valenzuela and Wang (2001)

Yes Yes Yes No

New instances

No

Babu N CX Nice Path ZDF

C11,C12,C13 C21,C22,C23 C31,C32,C33 C41,C42,C43 C51,C52,C53 C61,C62,C63 C71,C72,C73 Babu N1∼N13 50cx∼15,000cx Nice1∼Nice6 Path1∼Path6 zdf1∼zdf9

16,17 25 28,29 49 73 97 196,197 50 10∼3,152 50∼15,000 25∼1,000 25∼1,000 580∼5,032

20 40 60 60 60 80 160 11000 30∼640 400 100 100 1,003,000

20 15 30 60 90 120 240 375 40∼960 600 100 100 someknown

Data source

and T P stands for the test problem instances. The number of rectangles is denoted by n; H ∗ is the optimal height, and H ∗ = someknown denotes the optimal solutions of some instances in the corresponding data set which are known. In the following tables, h denotes the height found by different algorithms during one run, meanh and besth denote the average height and the best height, respectively, found by different algorithms during 10 runs, and meant denotes the average running time during 10 runs. The time unit is in seconds. The variable relategap denotes 100×((h or meanh or besth) − LB)/LB, where LB denotes the lower bound, and LB = H ∗ when the optimal solution is known. The variable meangap denotes the average relativegap for the considered instances. In the next section, the computational results of BSHA for problem types RF (see previous definition) and OF (the orientation of the rectangles is fixed) are reported. For all instances, the best meanh is shown in bold and the best besth is shown in bold italic. 5.1. Results for Problem Type RF We compare our algorithm with BF, BF + SA, BF + TS, BF + GA, and SPGAL. BF (Burke et al. 2004) is a new placement heuristic algorithm based on the bestfit strategy; BF + TS, BF + SA, and BF + GA (Burke et al. 2009) are the metaheuristic enhancements of BF heuristic; HRP (Huang et al. 2007) is an effective heuristic algorithm; HRBB (Cui et al. 2008) is a recursive branch-and-bound algorithm; and SPGAL is a genetic algorithm (Bortfeldt 2006). BF was performed on a PC with an 850 MHz CPU and 128 MB RAM; BF + TS, BF + SA, and BF + GA were conducted on a 2 GHz Pentium 4 computer with 256 MB RAM; HRP was run on an IBM notebook PC with 2.0 GHz processor and 256 MB memory; SPGAL was carried out on a Pentium PC with a core frequency of 2 GHz; and HRBB was run on a Pentium 4 CPU 2.80 GHz and main memory 512 MB. Our experiments were run on a Dell GX270 with 2.60 GHz CPU and 512 MB memory.

The computational results of class C are shown in Tables 2–4. Table 2 shows the solutions and running time of the 21 instances. BF + metaheuristic is allowed 60 seconds duration per run and the best solution (besth) is shown during 10 runs. We can observe that BSHA finds better meanh for 18 instances while BF + SA (the best BF + metaheuristic) fails to find a better besth. In particular, BSHA finds the optimal besth for all the instances. Tables 3 and 4 show the comparisons among HRBB, SPGAL, HRP and BSHA, where the best results of SPGAL during 10 runs are reported (Bortfeldt 2006). The computational results of HRBB and HRP are taken from Huang et al. (2007) and Cui et al. (2008). Table 3 shows the comparisons on relativegap. Table 4 shows the relative comparison of the running time of different algorithms. The meant of BSHA is less than 17.47 seconds, so BSHA is faster than most algorithms. In addition, the meangap obtained by BSHA is smaller than that obtained by all other algorithms mentioned. Table 5 shows the computational results of class Babu and N. BSHA is able to find the optimal solution to the instance Babu in a very short time. For the 13 instances of class N, BSHA finds better meanh for 11 instances and optimal besth for 12 instances in a short time, while BF + SA finds the optimal solutions of only two instances. Table 6 reports the computational results of BSHA on class CX. BSHA can find the optimal solutions of most instances except 50cx and 100cx, and it outperforms BL and GBMLA. It can be shown that BSHA is very effective for large zero-waste problems. Table 7 shows the computational results of class Nice and Path. Nice and Path belong to the non-zero-waste instance because they are transformed into integer data by multiplying by 10, and their optimal solutions are hard to obtain, so the running time of BSHA is long for most instances. However, we can observe that BSHA finds better solutions than BF and BF + metaheurisitc except Path3. For class Nice, we can also see that the solutions of BSHA are closer to the optimal solutions as the number of rectangles increases.


339


Table 2

Computational Results of Class C Instance ∗

BF

BF + TS

BF + SA

BF + GA

BSHA

h

Besth

Besth

Besth

Meanh

Besth

TP

W

n

H

C11 C12 C13

20 20 20

16 17 16

20 20 20

21 22 24

20 21 20

20 20 20

20 21 20

20 20 20

20 20 20

0003 0003 0001

C21 C22 C23

40 40 40

25 25 25

15 15 15

16 16 16

16 16 16

16 16 16

16 16 16

15 15 15

15 15 15

0013 0003 0012

C31 C32 C33

60 60 60

28 29 28

30 30 30

32 34 33

31 32 31

31 31 31

31 32 31

30 30 30

30 30 30

0025 1065 1059

C41 C42 C43

60 60 60

49 49 49

60 60 60

63 62 62

62 62 61

61 61 61

62 62 62

60 60 60

60 60 60

1091 3005 2079

C51 C52 C53 C61 C62 C63 C71 C72 C73

60 60 60 80 80 80 160 160 160

73 73 73 97 97 97 196 197 196

90 90 90 120 120 120 240 240 240

93 92 93 133 122 124 247 244 245

92 92 92 122 121 122 245 244 245

91 91 92 122 121 122 244 244 245

92 92 92 122 121 122 245 244 245

90 90 90 120 120 120 24008 240 24008

90 90 90 120 120 120 240 240 240

8093 0051 3003 12063 1028 24014 128026 4201 134048

Table 3

Meant

Comparisons of Relativegap on Class C C11∼13 C21∼23 C31∼33 C41∼43 C51∼53 C61∼63 C71∼73 Meangap

HRBB SPGAL HRP BSHA

Table 4

000 009 0 0

Babu N1 N2 N3 N4 N5 N6 N7 N8 N9 N10 N11 N12 N13

202 104 0 0

109 000 0 0

104 007 0083 0

103 005 0083 0022

104 100 0024 0003

C11∼13

C21∼23

C31∼33

C41∼43

C51∼53

C61∼63

C71∼73

Meant

00266 — 0047 0002

00328 — 0015 0006

0088 — 3009 1031

20187 — 166044 1094

20833 — 45025 11017

20239 — 873062 7070

40261 — 41276086 282030

1086 139 773013 17047

Computational Results of Class Babu and N Instance

TP

101 202 0 0

Comparisons of Running Time on Class C

HRBB SPGAL HRP BSHA

Table 5

107 107 0 0

W

n

H

∗

BF

BF + TS

BF + SA

BF + GA

BSHA

h

Besth

Besth

Besth

Meanh

Besth

Meant

11000

50

375

400

400

400

400

375

375

1098

40 30 30 80 100 50 80 100 50 70 70 100 640

10 20 30 40 50 60 70 80 100 200 300 500 31152

40 50 50 80 100 100 100 80 150 150 150 300 960

45 53 52 83 105 103 107 84 152 152 152 306 964

40 50 51 83 103 102 105 82 152 152 153 306 964

40 50 51 82 103 102 104 82 152 152 153 306 964

40 50 52 83 104 102 104 82 152 152 153 306 964

40 50 50 8006 101 100 101 80 150 150 150 30006 960

40 50 50 80 100 100 101 80 150 150 150 300 960

0000 0031 0041 22001 52085 3056 66018 5012 1016 0038 0067 20023 9064


340


Table 6

Computational Results of Class CX Instance

TP 50cx 100cx 500cx 1,000cx 5,000cx 10,000cx 15,000cx

BL

GBMLA

h

h

Meanh

Besth

Meant

674 679 692 690 687 681 660

673 668 677 663 647 637 634

60108 61002 600 600 600 600 600

601 610 600 600 600 600 600

112048 11329012 12068 0033 3052 12011 26051

∗

W

n

H

400 400 400 400 400 400 400

50 100 500 11000 51000 101000 151000

600 600 600 600 600 600 600

Figure 6 shows the packing results of instances C72, Nice6, N13, and 10,000cx for problem type RF. For instances C72, N13, and 10,000cx, BSHA finds their optimal solutions in which the sheet usage is 100%. 5.2. Results for Problem Type OF The above computational results showed that BSHA outperforms the current best algorithms for RF-type problems. In this section, we consider BSHA for problem type OF. To extend BSHA to solve OF-type problems, we replace “sort the rectangles in descending order of their area in R”, with “sort the rectangles in descending order of their width in R”, in procedures rls-rpp-packing(R, n, W, H, kmax, samemax, imax) and bsh-rspp-packing(R, n, W, H). In addition, we cancel the step “if wi < hi , then swap(wi 1 hi 5”, in procedure bsh-rspp-packing(R, n, W, H). To verify the performance of BSHA, we compare BSHA with GRASP. GRASP (Alvarez-Valdes et al. 2008) is one of the current excellent algorithms that outperforms most of the former algorithms. Alvarez-Valdes et al. (2008) reports the computational results of GRASP for problem type OF. GRASP was coded in C++ and run on a Pentium 4 Mobile at 2 GHz and was allowed 60 seconds duration per run, and the average solutions and the best solutions during 10 runs are shown. We test BSHA on class C, Babu, N, Nice and Path. The computational results of GRASP for all the instances are taken from Alvarez-Valdes et al. (2008). Table 7

Table 8 shows the computational results of BSHA on class C. From Table 8, we can observe that BSHA can find better meanh than GRASP for eight instances and better besth than GRASP for five instances while GRASP fails to find the better solution. Table 9 shows the computational results of BSHA on instances Babu and N. From Table 9, we can observe that BSHA can find better meanh for eight instances while GRASP is superior for one instance. BSHA can find better besth for eight instances, while GRASP cannot find the better besth. It is noted that besth of BSHA for class N is better than that of GRASP. Table 10 reports the computational results of BSHA for extra-large instances. From Table 10, we can observe that BSHA outperforms GRASP for most instances (except 100cx). It is shown that BSHA is very efficient and effective for extra-large zerowaste instances. Table 11 shows the computational results of BSHA on non-zero-waste instances Nice and Path. From Table 11, we can observe that BSHA can find better meanh and besth for eight instances while GRASP is superior for three instances. Table 12 tabulates the computational results of BSHA for nine large non-zero-waste instances. From Table 12, we can observe that BSHA can find the better meanh for eight instances while GRASP is superior for only one instance. BSHA can find the optimal besth for five instances within a short time while GRASP cannot

Computational Results of Class Nice and Path Instance

TP

BSHA

∗

BF

BF + TS

BF + SA

BF + GA

BSHA

h

Besth

Besth

Besth

Meanh

Besth

Meant

W

n

H

Nice1 Nice2 Nice3 Nice4 Nice5 Nice6

100 100 100 100 100 100

25 50 100 200 500 11000

100 100 100 100 100 100

10704 10805 10700 10503 10305 10307

106093 106064 105023 104021 103018 103080

104002 104041 105004 104074 103051 103076

108042 106087 105094 104089 103048 103080

102018 102028 101084 101012 100044 100018

100 01 102 01 10107 101 100 04 100 01

54055 252015 1117309 942035 886081 419049

Path1 Path2 Path3 Path4 Path5 Path6

100 100 100 100 100 100

25 50 100 200 500 11000

100 100 100 100 100 100

11001 11308 10703 10401 10307 10208

105082 103066 104073 103053 103015 102080

103009 10304 103004 103042 103048 102087

108017 103066 104037 103085 103041 102090

10005 101084 105037 102076 102018 101024

100 01 100 08 10501 102 04 102 01 10101

8084 252021 2127407 3162502 2186501 2113105


341


C72, H* = 240, h = 240

N13, H * = 960, h = 960 Figure 6

Nice6, H * = 100, h = 100.2

10,000cx, H * = 600, h = 600

Packing Results of Some Instances (RF)

find any optimal solution. It is shown that BSHA is very effective for large non-zero-waste instances. Figure 7 shows the packing results of instances C72, Nice6, N13, and 10,000cx for problem type OF. The experimental test can be summarized as follows: (1) The benchmark data for the experimental test include different types of data from the literature— for example, integer data and floating-point data, zero-waste data and non-zero-waste data, and small instances and large instances. Most instances mentioned above can be downloaded from Beasley (1990). (2) For RF-type problems, the running time of BSHA is longer than BF + metaheurisitc for several

instances, but BSHA is faster than BF + metaheurisitc for most instances. Moreover, BSHA outperforms the current best algorithms in terms of the quality of the solutions. (3) For OF-type problems, BSHA performs better than GRASP for zero-waste instances. For considered non-zero-waste instances, BSHA consumes a longer time than GRASP, but BSHA can a find better solution than GRASP. BSHA is not specially designed to solve OF-type problems, but it still performs better in an acceptable time than GRASP for most instances (class C, N, CX, zdf1∼zdf8), in particular, for large instances. (4) Please note that BSHA is different from other iterative improvement algorithms insofar as it may


342


Table 8

Computational Results of Class C Instance

TP

n

H

C11 C12 C13

16 17 16

C21 C22 C23

Table 11

GRASP ∗

BSHA

Instance

Meanh

Besth

Meanh

Besth

20 20 20

20 20 20

20 20 20

20 20 20

20 20 20

0 0031 0002

25 25 25

15 15 15

15 15 15

15 15 15

15 15 15

15 15 15

0008 0009 0001

C31 C32 C33

28 29 28

30 30 30

30 31 30

30 31 30

30 31 30

30 31 30

0018 15054 001

C41 C42 C43

49 49 49

60 60 60

61 61 61

61 61 61

61 61 6008

61 61 60

40044 48035 37071

C51 C52 C53

73 73 73

90 90 90

91 91 91

91 91 91

91 91 9008

91 91 90

88045 75013 88053

C61 C62 C63

97 97 97

120 120 120

12109 12109 12109

121 121 121

121 12102 121

121 121 121

221067 181056 170078

C71 C72 C73

196 197 196

240 240 240

244 24209 243

244 242 243

241 24108 241

241 241 241

434016 254062 468082

Table 9

TP Babu N1 N2 N3 N4 N5 N6 N7 N8 N9 N10 N11 N12 N13

Table 10

n

H

GRASP ∗

Besth

Meanh

Besth

50cx 100cx 500cx 1,000cx 5,000cx 10,000cx 15,000cx

Meant

50

375

375

375

375

375

5008

10 20 30 40 50 60 70 80 100 200 300 500 31152

40 50 50 80 100 100 100 80 150 150 150 300 960

40 50 51 81 102 101 101 81 151 151 151 30302 963

40 50 51 81 102 101 101 81 151 151 151 303 963

40 50 51 80 100 100 100 81 150 15104 150 301 96006

40 50 51 80 100 100 100 81 150 151 150 301 960

0 0002 11042 2027 27099 1018 8076 97085 8066 163016 15086 97051 163003

Computational Results of Class CX GRASP ∗

W

n

H

400 400 400 400 400 400 400

50 100 500 11000 51000 101000 151000

600 600 600 600 600 600 600

BSHA

Meanh Besth Meanh Besth 617 61707 60503 60209 600 600 600

TP

n

H

Nice1 Nice2 Nice3 Nice4 Nice5 Nice6

25 50 100 200 500 11000

Path1 Path2 Path3 Path4 Path5 Path6

25 50 100 200 500 11000

Table 12

GRASP ∗

Meanh

Besth

Meanh

Besth

Meant

100 100 100 100 100 100

10309 10407 10405 10308 10204 10203

10307 10406 104 10306 10202 10202

104064 103004 103004 101088 101 100045

10404 102 08 102 08 10106 100 09 100 04

78034 470056 41358008 31163013 31795022 2114504

100 100 100 100 100 100

10402 10109 10207 10203 10302 10207

10402 10108 10206 102 10301 10205

10402 100095 10403 105015 102095 102005

10402 100 08 104 10501 102 09 10105

21048 15301 41276012 8191008 161883091 81945066

Computational Results of Class ZDF Problem size

TP zdf1 zdf2 zdf3 zdf4 zdf5 zdf6 zdf7 zdf8 zdf9

BSHA

GRASP

BSHA

W

n

LB

Meanh

Besth

Meanh

Besth

Meant

100 100 100 100 100 31000 31000 31000 31000

580 660 740 820 900 11532 21432 21532 51032

330 357 384 407 434 41872 41852 51172 51172

333 360 387 410 437 51300 5119705 5155401 51476

333 360 387 410 437 51300 51163 51544 51476

33002 35706 38404 40704 434 51175 5118108 5152208 51566

330 357 384 407 434 51147 51172 51467 51566

7065 9072 6086 9004 5073 11302098 31152035 31000056 41609027

BSHA

Meanh

Instance TP

Meant

Computational Results of Class Babu and N Instance

Computational Results of Class Nice and Path

617 617 605 602 600 600 600

61208 62702 60002 600 600 600 600

608 611 600 600 600 600 600

Meant 13407 11280067 324004 86049 1008 79043 11166097

fail to find a solution for certain instances, given a time limit. For this reason we only report average running times for BSHA.

6.

Conclusions

Inspired by the experience of daily life, we have presented a least-waste-first strategy and a minimuminflexion-first strategy to find feasible positions for unpacked rectangles for a rectangular strip-packing problem. Based on the two strategies, a randomized local search heuristic algorithm is presented to efficiently solve the RPP. By using the idea of transforming the RSPP into the RPP, we can efficiently solve the RSPP. Then we developed a binary search heuristic algorithm based on randomized local search for the RSPP. From the computational results on a number of instances, we can see that BSHA is very effective and outperforms the current published best algorithms when BSHA is used to solve zero-waste problems. The preliminary computational experiments have shown that BSHA is not so effective for some non-zero-waste instances of small scale, so future work will focus on trying to improve its performance on these instances, as well as generally speeding up the algorithm for all non-zero-waste instances. In addition, we plan to perform a sensitivity analysis on solution quality versus computation time.


343


C72, H * = 240, h = 241

Nice6, H * = 100, h = 100.6

N13, H * = 960, h = 961 Figure 7

10,000cx, H* = 600, h = 600

Packing Results of Some Zero-Waste and Non-Zero-Waste Instances (OF)

Electronic Companion An electronic companion to this paper is available as part of the online version at http://dx.doi.org/10.1287/ ijoc.1120.0505.

Acknowledgments The authors thank the anonymous referees for their helpful comments and suggestions which contributed to the improvement of the presentation and the contents of this paper. Thanks to Prof. Ramon Alvarez-Valdes who helped

provide extra-large instances and the GRASP executable program. In particular, thanks to Prof. Sam Aceil who helped improve the language of the paper. This work is supported by the National Nature Science Foundation of China [Grant 60773126], the Province Nature Science Foundation of Fujian [Grant 2007J0037], the Academician Start-Up Fund [Grant X01109], and the 985 Information Technology Fund [Grant 0000–X07204] at Xiamen University. Readers should address correspondence to Liju Wei at [email protected].


344

beng5

beng5

25

N12

N12

300

N12

beng5

beng5

beng4

beng4

25

300

N12

beng4

beng4

beng3

beng3

beng3

beng3

beng2 300

25

300

N12

100

100

100

100

100

zdf1: n = 580, W = 100, H * = 330

zdf2: n = 660, W = 100, H * = 357

zdf3: n = 580, W = 100, H * = 384

zdf4: n = 820, W = 100, H * = 407

zdf5: n = 900, W = 100, H * = 434

100

3,000

zdf6: n = 1,532, W = 3,000, LB = 4,872 Figure 8

100

gcut13

gcut13

zdf7: n = 2,432, W = 3,000, LB = 4,852

600

3,000

zdf8: n = 2,532, W = 3,000, LB = 5,172

600

1,000cx

1,000cx

1,000cx

1,000cx

400

500cx

500cx

500cx

500cx

500cx

400

N8

3,000

1,000cx

5 1,000cx

5 500cx N8

…

N8

…

N8

30 N8 80

30 N5 N5

gcut13

N5

gcut13

N5

N5

100

beng2

25

300

25

beng2

beng2

beng1

beng1

beng1

beng1


3,000

zdf9: n = 5,032, W = 3,000, LB = 5,172

ZDF Instances

Appendix The instances from zdf1 to zdf9 are obtained by combining zero-waste and non-zero-waste instances (Figure 8). Where beng1∼beng5 and gcut13 belong to the non-zerowaste instance (Bengtsson 1982, Beasley 1985), N5, N8, and N12 belong to class N; 500cx, and 1,000cx belong to class CX. For example, zdf6 consists of 30 N5 and one gcut13, n = 30 × 50 + 32 = 1532; the width of N5 and gcut13 is 100 and 3,000 respectively, so W = 3000 = 30 × 100. The lower bound of gcut13 is 4,772, and the optimal height of N5 is 100, so LB = 100 + 4772 = 4872.

References Alvarez-Valdes R, Parreño F, Tamarit JM (2008) Reactive GRASP for the strip-packing problem. Comput. Oper. Res. 35:1065–1083. Baker BS, Coffman EG Jr, Rivest RL (1980) Orthogonal packing in two dimensions. SIAM J. Comput. 9(4):846–855. Beasley JE (1985) Algorithms for unconstrained two-dimensional guillotine cutting. J. Oper. Res. Soc. 36:297–306. Beasley JE (1990) OR-Library. http://people.brunel.ac.uk/~mastjjb/ jeb/info.html. Bengtsson BE (1982) Packing rectangular pieces—A heuristic approach. Comput. J. 25:353–357. Bortfeldt A (2006) A genetic algorithm for the two-dimensional strip-packing problem with rectangular pieces. Eur. J. Oper. Res. 172(3):814–837. Burke EK, Kendall G, Whitwell G (2004) A new placement heuristic for the orthogonal stock-cutting problem. Oper. Res. 52(4):655–671. Burke EK, Kendall G, Whitwell G (2009) A simulated annealing enhancement of the best-fit heuristic for the orthogonal stockcutting problem. INFORMS J. Comput. 21(3):505–516.

Chazelle B (1983) The bottom-left bin packing heuristic: An efficient implementation. IEEE Trans. Comput. 32(8):697–707. Cui Y, Yang Y, Cheng X, Song P (2008) A recursive branch-andbound algorithm for the rectangular guillotine strip-packing problem. Comput. Oper. Res. 35(4):1281–1291. Dagli CH, Poshyanonda P (1997) New approaches to nesting rectangular patterns. J. Intelligent Manufacturing 3(3):177–190. Dowsland KA, Dowsland WB (1992) Packing problems. Eur. J. Oper. Res. 56(1):2–14. Dowsland KA (1993) Some experiments with simulated annealing techniques for packing problems. Eur. J. Oper. Res. 68: 389–399. Dowsland KA, Herbert E, Kendall G, Burke E (2006) Using treesearch bounds to enhance a genetic algorithm approach to two rectangle packing problems. Eur. J. Oper. Res. 168:390–402. Hifi M (1999) The strip cutting/packing problem: Incremental substrip algorithms-based heuristics. Pesquisa Operacional, Special Issue on Cutting and Packing Problems 19(2):169–188. Hifi M, M’Hallah R (2003) A hybrid algorithm for the twodimensional layout problem: The cases of regular and irregular shapes. Internat. Trans. Oper. Res. 10:1–22. Hopper E, Turton BCH (2001) An empirical investigation of metaheuristic and heuristic algorithms for a 2D packing problem. Eur. J. Oper. Res. 128:34–57. Huang W, Chen D, Xu R (2007) A new heuristic algorithm for rectangle packing. Comput. Oper. Res. 34(11):3270–3280. Kröger B (1995) Guillotinable bin packing: A genetic approach. Eur. J. Oper. Res. 84(3):645–661. Liu D, Teng H (1999) An improved BL-algorithm for genetic algorithms of the orthogonal packing of rectangles. Eur. J. Oper. Res. 112(2):413–420. Lodi A, Martello S, Monaci M (2002) Two-dimensional packing problems: A survey. Eur. J. Oper. Res. 141(2):241–252. Lodi A, Martello S, Vigo D (1999) Heuristic and metaheuristic approaches for a class of two-dimensional bin packing problems. INFORMS J. Comput. 11(4):345–357.

Zhang et al.: Randomized Local Search for the Rectangular Strip Packing Problem INFORMS Journal on Computing 25(2), pp. 332–345, © 2013 INFORMS

Martello S, Pisinger D, Vigo D (2000) The three-dimensional bin packing problem. Oper. Res. 48:256–267. Martello S, Monaci M, Vigo D (2003) An exact approach to the strip-packing problem. INFORMS J. Comput. 15(3): 310–319. Oliveira JFC, Ferreira JAS (1993) Algorithms for nesting problems. Vidal RVV ed. Applied Simulated Annealing, LNEMS 396 (Springer) 255–274. Pinto E, Oliveira JF (2005) Algorithm based on graphs for the non-guillotinable two-dimensional packing problem. Second ESICUP Meeting, Southampton. Pisinger D (2002) Heuristics for the container loading problem. Eur. J. Oper. Res. 141(2):382–392. Ramesh Babu A, Ramesh Babu N (1999) Effective nesting of rectangular parts in multiple rectangular sheets using genetic and heuristic algorithms. Internat. J. Productions Res. 37(7):1625–1643.

345

Valenzuela CL, Wang PY (2001) Heuristics for large strip packing problems with guillotine patterns: An empirical study. Proc. 4th Metaheuristics Internat. Conf. 417–421. Wäscher G, Haußner H, Schumann H (2007) An improved typology of cutting and packing problems. Eur. J. Oper. Res. 183:1109–1130. Wu Y, Huang W, Lau S, Wong CK, Young GH (2002) An effective quasi-human based heuristic for solving the rectangle packing problem. Eur. J. Oper. Res. 141(2):341–358. Zhang D, Kang Y, Deng A (2006) A new heuristic recursive algorithm for the strip rectangular packing problem. Comput. Oper. Res. 33(8):2209–2217. Zhang D, Liu Y, Chen S, Xie X (2005) A metaheuristic algorithm for the strip rectangular packing problem. Lecture Notes in Comput. Sci. 3612:1235–1241.