2016 Hybrid Approach For The Two-Dimensional Bin Packing Problem

INTERNATIONAL
TRANSACTIONS
IN OPERATIONAL
Intl. Trans. in Op. Res. 23 (2016) 539–549 RESEARCH
DOI: 10.1111/itor.12188
Hybrid approach for the two-dimensional bin packing problem

with two-staged patterns
Yaodong Cuia,b , Yi Yaoa,b and Yi-Ping Cuib
a
College of Computer and Electronic Information, Guangxi University, Nanning, China
b
School of Business Administration, South China University of Technology, Guangzhou, China
E-mail: ydcui@263.net [Y. Cui]; yipingcuiv@gmail.com [Y.-P. Cui]
Received 18 September 2014; received in revised form 28 February 2015; accepted 19 May 2015
Abstract
This paper presents a two-phase heuristic approach for the two-dimensional bin packing problem with two-
staged patterns and nonoriented items. A solution is generated in each phase and the better one is selected.
Residual problems are solved by column generation in the first phase, where a partial admitting procedure is
used to admit some of the patterns into the phase-1 solution. The second solution is obtained from solving
an integer linear programming problem over the set of all patterns generated in the first phase, where a time
limit is used and subsequently the solution may not be optimal over the pattern set. The computational results
indicate that the approach yields the best solution quality among the heuristics that use two-staged or more
complex patterns.
Keywords: two-dimensional bin packing; two-staged patterns; integer programming; column generation
1. Introduction
In the two-dimensional bin packing (2BP) problem, n items of lengths (l1 , . . . , ln ) and widths
(w1 , . . . , wn ) are packed orthogonally and without overlap into bins L ⊗ W (length ⊗ width) so
that the number of bins used is minimized. The problem is referred to as the two-dimensional
single bin size bin packing problem in Wäscher et al. (2007). This paper focuses on the subtype
2BPRG_2Stg, where R denotes that item rotation is allowed, that is, an item can be placed with
either the length or width in horizontal orientation; G denotes that guillotine cuts are required;
2Stg represents the use of two-staged patterns. This problem becomes the 2BPOG_2Stg when the
items are oriented (O). The following paragraphs briefly review the approaches for 2BPRG_2Stg.
Most of them can also solve the 2BPOG_2Stg. The reader is referred to Lodi et al. (2002a, 2002b)
for surveys of heuristics and exact methods for 2BP.
Two heuristics for 2BPRG_2Stg are presented in Lodi et al. (1998). The first is the finite best
strip (FBS) heuristic that contains two phases. Items are packed into strips in the first phase and

C 2015 The Authors.
International Transactions in Operational Research
C 2015 International Federation of Operational Research Societies
Published by John Wiley & Sons Ltd, 9600 Garsington Road, Oxford OX4 2DQ, UK and 350 Main St, Malden, MA02148,
USA.
540 Y. Cui et al. / Intl. Trans. in Op. Res. 23 (2016) 539–549
the strips into bins in the second. The second heuristic is the finite first fit. It packs items into strips
created directly inside bins.
A knapsack problem based heuristic KPRG for 2BPRG_2Stg is available in Lodi et al. (1999).
It solves 0–1 knapsack problems to determine the item layouts on the strips. The algorithm has
exponential complexity because it packs strips into bins by solving the one-dimensional bin packing
problem exactly.
Two tabu-search heuristics, TSFBS and TSKP, are also presented in Lodi et al. (1999). The
subordinate inner heuristic used is FBS in TSFBS. It is KPRG in TSKP. Other heuristics include the
VND (variable neighborhood descent) in Alvelos et al. (2009) and the SNS (stochastic neighborhood
structure) in Chan et al. (2011).
Integer linear programming (ILP) models for 2BP*G_2Stg (both 2BPOG_2Stg and
2BPRG_2Stg) are introduced in Lodi et al. (2004). They involve polynomial number of variables
and constraints. Recently, Alvelos et al. (2014) implemented the model for the oriented items, using
CPLEX 12.4. They performed computations on a desktop computer with an Intel Core i7—3.3
GHz processor and with 32 GB RAM, using the 500 instances later described in the experimental
part of this paper. The time limit for an instance was 3600 seconds. The implementation obtained
solutions for all instances. The total number of bins used by all instances is 7364. The average
computation time of an instance is 84 seconds. Although recent implementations of the model for
the nonoriented items are not reported, the computation time may be significantly longer than those
of the heuristic algorithms.
A two-phase approach for 2BPRG_2Stg is presented. It is denoted as HHBP (hybrid heuristic
for the two-dimensional bin packing problem). The HHBP generates a solution in each phase
and selects the better one. Residual problems are solved by column generation (CG) in the first
phase, where a partial admitting procedure is used to admit some of the patterns into the phase-1
solution. The admitting procedure is useful for both improving the quality of the phase-1 solution
and preparing a large set of potential patterns for phase-2. The second solution is obtained from
solving an ILP over all patterns generated in the first phase. It may be not optimal over the pattern
set because of the time limit. The computational results indicate that the approach can yield the
best solution quality among the heuristics that use two-staged or more complex patterns. The main
contributions of the HHBP can be summarized as follows:
(1) An effective implementation of the CG method. The approach is effective in improving solution
quality mainly because of the proposed admitting procedure.
(2) A good algorithm for solving the 2BP with two-staged patterns and nonoriented items. It can
yield the best average solution quality for the benchmark instances tested. This is helpful to
applications that require high-quality solutions.
(3) A useful framework for solving the general 2BP. Although the approach is described for the
2BP with two-staged patterns, the framework can also be used for the 2BP with other types of
patterns.
It should be noted that the combination of the CG with heuristics for the 2BP has been effectively
used in several works (Monaci and Toth, 2006; Pisinger and Sigurd, 2007; Puchinger and Raidl,
2007; Alvelos et al., 2014), where oriented items are assumed.

C 2015 The Authors.
Y. Cui et al. / Intl. Trans. in Op. Res. 23 (2016) 539–549 541
The set covering based heuristic approach in Monaci and Toth (2006) considers free (nonguillo-
tine) patterns. However, it does contain two phases. In the first phase, greedy procedures and fast
constructive heuristic algorithms from the literature are used to generate a set of cutting patterns.
In the second phase, a set-covering problem is solved over the generated patterns to obtain the
solution.
A hybrid approach for the 2BP based on CG is available in Pisinger and Sigurd (2007). It
constructs each pattern by solving a constraint-satisfaction problem (CSP). Either free or guillotine
patterns can be used. The CSP is solved not only to construct the patterns but also to generate valid
inequalities in a branch-and-cut system.
Puchinger and Raidl (2007) presented ILP models for the 2BPOG with restricted and unrestricted
three-staged patterns. Both models involve polynomial numbers of variables and constraints and are
solved using CPLEX. They also presented a branch-and-price (B&P) algorithm for a set covering
formulation of the unrestricted problem. They used the CG in the proposed B&P framework to solve
the set covering model, where four algorithms are used to generate the patterns. The computational
results show that the latter approach performs better than the former.
Alvelos et al. (2014) considered the 2BPOG with two-staged and restricted three-staged patterns.
They proposed a decomposition model where the subproblem is related with the item that initializes
a bin, and presented a heuristic to solve the model, combining CG, local search, beam branch and
price, and the use of a general purpose mixed integer programming solver.
The differences between the HHBP of this paper and the four approaches just reviewed include
one or several of the following aspects:
(1) Different assumptions of the item orientation. Only the HHBP considers nonoriented items.
(2) Different pattern types. Only the HHBP and Alvelos et al. (2014) use two-staged patterns.
(3) Different methods for constructing the patterns.
(4) Different implementations of the CG.
(5) Although both the HHBP and the approach in Monaci and Toth (2006) contain two phases, the
latter does not obtain a phase-1 solution. The phase-1 solution of the HHBP is useful because
it may be better than the phase-2 solution.
The remainder of the paper is arranged as follows. The proposed approach is described in the
next section. The computational results are presented in Section 3. The conclusions are given in the
last section.
2. Proposed approach for the 2BPRG_2Stg
Two-staged patterns are used. A two-staged pattern can be divided into items in two stages. Hori-
zontal cuts in the first stage divide the bin into strips, and vertical cuts in the second stage split the
strips into items. Figure 1 shows a two-staged pattern that contains three horizontal strips, where
each number denotes the ID of an item.
The solution of the 2BPRG_2Stg contains a group of different two-staged patterns, where the
frequency (number of times to use) of each pattern is 1. The approach obtains the solution from
solving the following ILP:

C 2015 The Authors.
Fig. 1. A two-staged pattern.

K
K
Z = min xk ; aik xk ≥ 1, i = 1, . . . , n; xk ∈ {0, 1} , k = 1, . . . , K,
k=1 k=1
where the considered pattern set = {P1 , . . . , PK }; xk is a 0–1 variable representing the frequency
of pattern Pk , k = 1, . . . , K; aik is a 0–1 constant denoting whether item i is included in pattern Pk
No), i = 1, . . . , n, k = 1, . . . , K. The objective is to minimize the number of bins
(1 for Yes and 0 for
used. Constraint K k=1 aik xk ≥ 1 denotes that each item should be included in the solution, where
surplus items are allowed but taken as waste. The approach consists of two phases. It determines
the patterns in in phase-1 and solves the ILP using CPLEX in phase-2. It is necessary only to
detail the contents of the approach in phase-1.
Consider the following linear programming model (LPM):
K

K
Z = min xk ; aik xk =1, i = 1, . . . , n; 0 ≤ xk ≤ 1; k = 1, . . . , K.
k=1 k=1
K
It is obtained from the ILP by replacing Kk=1 aik xk ≥ 1 with k=1 aik xk =1 and replacing xk ∈ {0, 1}
with 0 ≤ xk ≤ 1. The LPM is solved to obtain the patterns in , meanwhile a phase-1 solution is
obtained to provide a bound for the value of the phase-2 solution to speed up the solution process.
n
Initially there are no patterns in the phase-1 solution. Let ZCLB = ( i=1 li wi )/(LW ) be the
continuous lower bound of the bin count. The steps of the algorithm (denoted as HHBP) are as
follows:
Phase-1:
1. Let the initial residual problem be the original problem, while there are remaining items.
2. Solve the LPM of the current residual problem.
3. Call AdmitPats to admit some patterns into phase-1 solution.
4. Add all patterns generated in solving the current LPM to .

C 2015 The Authors.
Phase-2:
5. If phase-1 solution has value equal to ZCLB then output it and stop.
6. Use CPLEX to solve the ILP to obtain the phase-2 solution.
7. Output the better solution.
The phase-1 solution is a partial one before the termination of the phase. The original problem
is characterized by the ILP and contains all required items. The current residual problem contains
the items not included in the partial solution.
Steps 2–4 solves the LPMs of the residual problems repeatedly until all items are included in the
solution. Step 2 solves the LPM (the main problem) of the current residual problem using the CG,
where the following subproblem is solved in each run of the CG iteration to obtain a new pattern
P:
n

U = max ci yi ; P is a two-staged pattern; yi ∈ {0, 1} and yi ≤ ri ; i = 1, . . . , n,
i=1
where yi = 1 if item i is included and yi = 0 otherwise; ri = 1 if item i is among the remaining

items, ri = 0 otherwise; (c1 , . . . , cn ) are the duals obtained from the current LPM solution. If
the pattern value U is larger than 1, then the pattern is introduced and the iteration continues;
otherwise the iteration terminates. The C_SLOPP procedure in Section 3 of Cui and Zhao (2013)
is used to solve the subproblem. It contains two subprocedures based on simple recursions: the
strip-generation procedure with complexity O(2n2 L) and the pattern-generation procedure with
complexity O(2n2W ). Initially pattern P contains no items. The C_SLOPP procedure is run G times
to determine the pattern. In each run, the strip-generation procedure generates a set of strips using
all remaining items (in the first run) or a subset of them (in other runs), and the pattern-generation
procedure uses the strips in the set to improve the pattern. Parameter G is set to be min(W, 10) in
this paper.
Let fmax be the maximum fractional part of the pattern frequencies in the solution to the current
LPM, then 0 ≤ fmax < 1. Let ε be a parameter with value in [0, 1]. Step 3 calls the partial admitting
procedure AdmitPats to admit some of the patterns generated in solving the current LPM into
the phase-1 solution. Let P be the pattern currently under consideration, P = [y1 , . . . , yn ] and
the frequency (in the LPM solution) is f . The contents of the procedure are as follows and the
explanations are given immediately afterwards.
1. Sort the patterns according to the nonincreasing order of their frequencies in the LPM solution.
2. Consider the patterns one by one:
2.1 if f ≥ ε fmax and yi ≤ ri for all i ∈ {1, . . . , n} then
2.2 admit the pattern into the phase-1 solution,
2.3 let ri ← ri − yi for all i ∈ {1, . . . , n}.
The procedure first sorts the patterns according to the nonincreasing order of their frequencies
in the LPM solution (Step 1), then considers them one by one (Step 2). If the current pattern has
frequency not smaller than ε fmax , and admitting it into the phase-1 solution does not produces
surplus items (Step 2.1), the procedure admits the pattern and updates the remaining items by

C 2015 The Authors.
Table 1
Features of the instances in Classes 1–6
Class 1 2 3 4 5 6
Bin size (L = H ) 10 30 40 100 100 300
Range for li and wi [1, 10] [1, 10] [1, 35] [1, 35] [1, 100] [1, 100]
deleting those included (Steps 2.2 and 2.3). At least one pattern will be admitted because of
constraint yi ∈ {0, 1} in the sum problem. This guarantees the convergence of the algorithm. The
patterns with frequency 1 will be admitted because 1 > ε fmax always holds. This indicates that the
number of patterns admitted in solving each LPM may be larger than 1. The number of patterns
admitted may increase with the decrease in the ε value. The procedure is referred to as a full one
when ε= 0. It is a partial one in this paper because ε= 1 is assumed in the general computational
test of Section 3.
The phase-1 solution contains all items at the end of the phase. If its value Z1 is equal to ZCLB ,
then the solution is selected as the final one (Step 5). Otherwise, Z1 − 1 and ZCLB are used as bounds
for the solution process of phase-2, in which CPLEX can discard branches with lower bound larger
than Z1 − 1, and stop computation once the value Z2 of the phase-2 solution reaches ZCLB . This
is useful to reduce computation time. The bound Z1 − 1 can be used because only the Z2 values
smaller than Z1 are expected at this stage. The following cases may exist for the phase-2 solution.
1. Infeasible. This can happen when Z1 is already optimal, or the computation time reaches the
limit before obtaining a feasible solution.
2. Feasible but not optimal over the pattern set. This can happen because of the time limit.
3. Optimal over the pattern set. If the first case happens then the phase-1 solution is selected as the
final one. Otherwise the phase-2 solution is selected.
3. Computational results
There are three subsections. The HHBP is compared with the algorithms for the 2BPRG_2Stg in
the first subsection. It is compared with the algorithms for 2BPRG with other pattern types in the
second. Some specialized tests are given in the last.
The HHBP is coded with C# and executed on a Dell computer (Inspiron 3847, CPU of Intel
core i5-4440 3.3 GHz, RAM of 8 GB). Version 12.5 of the CPLEX is used as optimization engine.
The time limit for CPLEX in Step 6 of the algorithm is 50 seconds. ε = 1 is assumed in the partial
admitting procedure (see Step 3 and the related explanation).
Ten classes of benchmark instances are used. Each class contains five groups and each group
includes 10 instances with the same number of items (n). The first six classes were generated in
Berkey and Wang (1987). The bin size and ranges for generating the items are listed in Table 1. The
last four classes (Classes 7–10) were described in Lodi et al. (1999). They contain four item types:
(1) li in [1, 1/2L] and wi in [2/3W, W ] ; (2) li in [2/3L, L] and wi in [1, 1/2W ] ; (3) li in [1/2L, L]
and wi in [1/2W, W ] ; (4) li in [1, 1/2L] and wi in [1, 1/2W ] . The bin size is L = W = 100 for all

C 2015 The Authors.
Table 2
Percentage of each item type in an instance of Classes 7–10
Type 1 Type 2 Type 3 Type 4

Class 7 70 10 10 10
Class 8 10 70 10 10
Class 9 10 10 70 10
Class 10 10 10 10 70
Table 3
Average number of bins used by the solution to an instance
n 20 40 60 80 100
Class 1 6.8 13 19.5 27 31.3
Class 2 1 2 2.8 3.3 4
Class 3 4.7 9.4 13.4 18.3 22
Class 4 1 2 2.8 3.3 4
Class 5 5.9 11.4 17.4 24 27.7
Class 6 1 2 2.3 3 3.6
Class 7 5.3 10.2 14.6 20.8 25
Class 8 5.3 10.4 14.7 20.4 25.2
Class 9 14.3 27.5 43.5 57.3 69.3
Class 10 4.1 7.3 9.9 12.6 15.8
instances. Each instance contains four item types. The percentage of each item type in an instance
is given in Table 2.
3.1. Comparing HHBP with 2BPRG_2Stg algorithms
Although the approach in Lodi et al. (2004) can solve the 2BP*G_2Stg exactly, complete
2BPRG_2Stg solutions to this set of instances have not been reported. The following heuristics
are compared with the HHBP: KP the heuristic KPRG in Lodi et al. (1999). TSKP the heuristic
from Lodi et al. (1999). FBS2 the FBS based heuristic from Fleszar (2013). VND the heuristic
from Alvelos et al. (2009); the results are obtained from Chan et al. (2011). SNS the heuristic from
Chan et al. (2011). RCCG the heuristic for the 2D cutting stock problem with two-staged patterns
(2DCSP_2Stg) from Cui and Zhao (2013). The 2BPRG_2Stg can be solved because it is generalized
by the 2DCSP_2Stg. The results are obtained by running RCCG on a computer with Intel Xeon
CPU E5506 2.13GHz, RAM 4 GB.
The detailed results of HHBP are given for all subclasses in Table 3. The total number of bins used
by each class is shown in Table 4. The total number (N) of bins used by the whole set of instances
is listed in Table 5, where the algorithms are arranged in ascending order of their N values; and the
GAP in the table denotes the difference between the total number of bins used by the HHBP and
that used by a particular algorithm.
The following observations obtained from Tables 4 and 5 indicate that the solution quality of the
HHBP is better than those of other algorithms: The total number of bins used by the HHBP is the

C 2015 The Authors.
Table 4
Number of bins used by each class
Class HHBP SNS RCCG VND FBS2

1 976 981 986 992 997
2 131 128 136 132 130
3 678 699 699 702 727
4 131 127 128 133 127
5 864 879 883 895 902
6 119 116 116 120 115
7 759 788 770 786 843
8 760 788 772 792 845
9 2119 2119 2145 2119 2119
10 497 511 508 535 514
Table 5
Total number of bins used by all classes
Algorithm HHBP TSKP SNS RCCG VND KP FBS2

N 7034 7101 7136 7143 7206 7297 7319
GAP 0 67 102 109 172 263 285
smallest. HHBP performs better than SNS in six classes, the same in one class, and worse in three
classes; better than RCCG in eight classes and worse in two classes; better than VND in nine classes
and the same in one class; better than FBS2 in six classes, the same in one class, and worse in three
classes.
The average computation time of an instance is 20.72 seconds for HHBP and 90.66 seconds for
RCCG. The other algorithms are very fast and their computation time can be seen as negligible.
Although the computation time is much longer than these algorithms, the HHBP is useful for
applications that require high-quality solutions.
3.2. Comparing HHBP with 2BPRG algorithms that use nonstaged patterns
The following algorithms that use nonstaged patterns are compared with HHBP, where nonstaged
means that the constraint on the number of stages is not considered in generating the patterns: A-B
the agent-based heuristic from Polyakovsky and M’Hallah (2009); CHBP the constructive heuristic
with bias and postprocessing from Charalambous and Fleszar (2011); CFIHJ4 the best insertion
heuristic in Fleszar (2013); SVCRG the algorithm in Cui et al. (2015).
The total number of bins used by each class is shown in Table 6. The total number of bins used by
the whole set of instances is listed in Table 7. The following observations obtained from the tables
indicate that high solution quality can also be obtained using two-staged patterns that are simple to
cut/pack. The total number of bins used by HHBP is the smallest. Compared with the SVCRG, the
HHBP performs better in six classes, the same in one class, and worse in three classes. Compared

C 2015 The Authors.
Table 6
Number of bins used by each class
Class HHBP SVCRG A-B CHBP CFIHJ4

1 976 973 974 975 975
2 131 132 124 124 125
3 678 681 691 687 686
4 131 123 122 125 125
5 864 868 878 872 873
6 119 114 113 113 113
7 759 761 766 770 781
8 760 765 772 776 779
9 2119 2119 2119 2119 2119
10 497 499 504 503 504
Table 7
Comparing HHBP with other 2BPRG algorithms
Algorithm HHBP SVCRG A-B CHBP CFIH_J4

N 7034 7035 7063 7064 7080
Table 8
Impact of ε values on the solution quality
Class 1 2 3 4 5 6 7 8 9 10 Total
ε=0 984 132 692 131 870 121 760 766 2119 505 7080
ε = 0.5 982 132 685 131 864 121 759 763 2119 502 7058
ε=1 976 131 678 131 864 119 759 760 2119 497 7034
with the A-B, CHBP, and CFIHJ4, the HHBP performs better in five classes, the same in one class,
and worse in four classes.
Although the computation times are not reported (the computation time of the HHBP is available
in the last paragraph of Section 3.1), the other algorithms are faster than the HHBP. The HHBP
is welcomed when simple patterns are required. Its computation time may be reasonable for some
applications.
3.3. Specialized tests
As mentioned in Section 2, after the LPM of each residual problem is solved in Step 2 of the HHBP,
the partial admitting procedure admits some of the generated patterns into the phase-1 solution. It
considers only the patterns with frequency not smaller than ε fmax . ε = 1 has been assumed in the
previous computation. Table 8 shows the number of bins used by each class for different ε values,
where ε = 0 is related with full admitting. The total number of bins used by the whole set is listed
in the last column. It is seen that the solution quality generally improves with the increase in the ε
value.

C 2015 The Authors.
Table 9
Number of solutions improved by phase-2
Class 1 2 3 4 5 6 7 8 9 10
Number 21 0 29 0 23 0 13 14 5 17
After the LPM of the current residual problem is solved, the number of admitted patterns for
ε = 1 may be smaller than that for ε < 1. Full admitting procedures (equivalent to ε = 0) are often
used in the residual heuristics of the literature (e.g., Cui and Zhao, 2013). It is seen that the partial
admitting procedure of this paper (the case of ε = 1) is useful in improving the solution quality. The
main reason is as follows. Using ε = 1 to admit a small number of patterns increases the number
of residual problems in phase-1, subsequently the number of patterns in set is increased. This is
useful for phase-2 to obtain a better solution.
The numbers of solutions improved by phase-2 (related with the results in Table 3) are shown
in Table 9. The total number of solutions improved is 122, indicating that phase-2 of the HHBP is
important for the improvement of the solutions.
4. Conclusions
The following comments can be made about the HHBP and its contributions:
(1) The HHBP is powerful in improving solution quality because of the clever combination and
adaptation of two efficient approaches: (a) the residual heuristic in the first phase that generates
a large set of potential patterns and provides a good phase-1 solution; (b) the solving of the ILP
over the generated patterns in the second phase. The experimental part shows that the HHBP
is able to provide very competitive results according to the methods proposed in the literature.
Thus, this contribution is valuable as the most efficient heuristic method to solve the problem.
(2) Admitting procedures are necessary for residual heuristics. The computational results in Table
7 indicate that the implementation in this paper (selecting a small number of the admissible
patterns) is better in solution quality than the general implementation that admits as many
patterns as possible.
(3) Complete exact solutions to the 2BPRG_2Stg have not been reported so far for this set of
instances. This may indicate that the exact approach is still not adequate for solving the large
instances in the set (in the sense of obtaining a solution close to optimal), using the personnel
computers nowadays. The solution quality of the HHBP is better than those of the published
heuristics for the 2BPRG_2Stg. Although the solution time of the HHBP is longer, it may be
acceptable for many applications. Fast and effective bounded knapsack algorithms can be tried
to reduce the computation time of the HHBP. This may serve as future work.
(4) The computational results show that the HHBP is even able to compete in solution quality with
the published methods that use complex patterns. Using the HHBP is useful to reduce the total
cost because two-staged patterns are simple to cut/pack.

C 2015 The Authors.
Acknowledgments
This research is part of Projects 61363026 and 71371058 supported by National Natural Science
Foundation of China.
References
Alvelos, F., Chan, T.M., Vilaça, P., Gomes, T., Silva, E., Valério de Carvalho, J.M., 2009. Sequence based heuristics for
two-dimensional bin packing problems. Engineering Optimization 41, 773–791.
Alvelos, F., Silva, E., Valério de Carvalho, J.M., 2014. A hybrid heuristic based on column generation for two- and
three-stage bin packing problems. Computational Science and Its Applications–ICCSA 2014. Springer International
Publishing, Cham, Switzerland, pp. 211–226.
Berkey, J., Wang, P., 1987. Two-dimensional finite bin-packing algorithms. Journal of the Operational Research Society
38, 423–429.
Chan, T.M., Alvelos, F., Silva, E., Valério de Carvalho, J.M., 2011. Heuristics with stochastic neighborhood structures for
two-dimensional bin packing and cutting stock problems. Asia-Pacific Journal of Operational Research 28, 255–278.
Charalambous, C., Fleszar, K., 2011. A constructive bin-oriented heuristic for the two-dimensional bin packing problem
with guillotine cuts. Computers & Operations Research 38, 1443–1451.
Cui, Y., Zhao, Z., 2013. Heuristic for the rectangular two-dimensional single stock size cutting stock problem with
two-staged patterns. European Journal of Operational Research 231, 288–298.
Cui, Y.-P., Cui, Y., Tang, T., 2015. Sequential heuristic for the two-dimensional bin-packing problem. European Journal
of Operational Research 240, 43–53.
Fleszar, K., 2013. Three insertion heuristics and a justification improvement heuristic for two-dimensional bin packing
with guillotine cuts. European Journal of Operational Research 40, 463–474.
Lodi, A., Martello, S., Vigo, D., 1998. Neighborhood search algorithm for the guillotine non-oriented two-dimensional
bin packing problem. In Voss, S., Martello, S., Osman, I., Roucairol, C. (eds) Meta-Heuristics: Advances and Trends
in Local Search Paradigms for Optimization. Kluwer Academic Publishers, New York, pp. 125–139.
Lodi, A., Martello, S., Vigo, D., 1999. Heuristics and metaheuristic approaches for a class of two-dimensional bin packing
problems. INFORMS Journal on Computing 11, 345–357.
Lodi, A., Martello, S., Vigo, D., 2002a. Recent advances on two-dimensional bin packing problems. Discrete Applied
Mathematics 123, 296–379.
Lodi, A., Martello, S., Vigo, D., 2002b. Two-dimensional packing problems: a survey. European Journal of Operational
Research 141, 241–252.
Lodi, A., Martello, S., Vigo, D., 2004. Models and bounds for two-dimensional level packing problems. Journal of
Combinatorial Optimization 8, 363–379.
Monaci, M., Toth, P., 2006. A set-covering-based heuristic approach for bin-packing problems. INFORMS Journal on
Computing 18, 71–85.
Pisinger, D., Sigurd, M., 2007. Using decomposition techniques and constraint programming for solving the two-
dimensional bin packing problem. INFORMS Journal on Computing 19, 36–51.
Polyakovsky, S., M’Hallah, R., 2009. An agent-based approach to the two-dimensional guillotine bin packing problem.
European Journal of Operational Research 192, 767–781.
Puchinger, J., Raidl, G.R., 2007. Models and algorithms for three-stage two-dimensional bin packing. European Journal
of Operational Research 183, 1304–1327.
Wäscher, G., Haussner, H., Schumann, H., 2007. An improved typology of cutting and packing problems. European
Journal of Operational Research 183, 1109–1130.

C 2015 The Authors.

2016 Hybrid Approach For The Two-Dimensional Bin Packing Problem

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

2016 Hybrid Approach For The Two-Dimensional Bin Packing Problem

Uploaded by

Copyright:

Available Formats

INTERNATIONAL

Hybrid approach for the two-dimensional bin packing problem

2. Proposed approach for the 2BPRG_2Stg

Fig. 1. A two-staged pattern.

where yi = 1 if item i is included and yi = 0 otherwise; ri = 1 if item i is among the remaining

Type 1 Type 2 Type 3 Type 4

3.1. Comparing HHBP with 2BPRG_2Stg algorithms

Class HHBP SNS RCCG VND FBS2

Algorithm HHBP TSKP SNS RCCG VND KP FBS2

Class HHBP SVCRG A-B CHBP CFIHJ4

Algorithm HHBP SVCRG A-B CHBP CFIH_J4

3.3. Specialized tests

You might also like