Computers & Operations Research 36 (2009) 2801 -- 2815

Contents lists available at ScienceDirect

Computers &Operations Research

journal homepage: www.e lsev ier .com/ locate /cor

Three-dimensional packingswith rotations�

F.K. Miyazawaa,∗, Y. WakabayashibaInstituto de Computação, Universidade Estadual de Campinas, Caixa Postal 6176, 13084-971 Campinas, SP, BrazilbInstituto de Matemática e Estatística, Universidade de São Paulo, Rua do Matão, 1010, 05508-090 São Paulo, SP, Brazil

A R T I C L E I N F O A B S T R A C T

Available online 8 January 2009

Keywords:Packing problemsApproximation algorithmsOrthogonal rotations

We present approximation algorithms for the three-dimensional strip packing problem, and the three-dimensional bin packing problem. We consider orthogonal packings where 90◦ rotations are allowed. Thealgorithms we show for these problems have asymptotic performance bounds 2.64, and 4.89, respectively.These algorithms are for the more general case in which the bounded dimensions of the bin given in theinput are not necessarily equal (that is, we consider bins for which the length, the width and the heightare not necessarily equal). Moreover, we show that these problems—in the general version—are as hardto approximate as the corresponding oriented version.

© 2009 Elsevier Ltd. All rights reserved.

1. Introduction

We focus on orthogonal packing problems where 90◦ rotationsare allowed. These problems have many real-world applications[1,2]: job scheduling, container loading, cutting of hardboard, glass,foam, etc.

We present approximation algorithms for the three-dimensionalversions of the strip packing and the bin packing problems. In thed-dimensional version of both problems, d�1, the input consists ofa list of d-dimensional items (not necessarily of equal sizes) and a d-dimensional bin B. In the d-dimensional strip packing problem (dSP),defined only for d�2, one of the dimensions of the bin B, say height,is unlimited, and the goal is to pack the list of items into B so as tominimize the height of the packing. In the d-dimensional bin packingproblem (dBP), the dimensions of the bin B are limited, and the goalis to pack the list of items into a minimum number of bins.

These problems and others of this nature have been more inves-tigated in the version in which the packing is required to be oriented.In this version, the items and the bins are given with an orientationwith respect to a coordinate system, and the items must be packedinto the bins in this given orientation. In this paper, we considerpackings that allow orthogonal rotations (that is, the items to bepacked may be rotated by 90◦ around any of the axes); to distinguishthem we may refer to them as r-packings or packings with rotation

�This research was partially supported by CNPq (Proc. 478470/06–1, 472504/07-0, 306624/07-9, 305702/07-6 and 490333/04-4) and ProNEx-FAPESP/CNPq (Proc.03/09925-5).∗ Corresponding author. Tel.: +551935215882; fax: +551935215847.E-mail addresses: fkm@ic.unicamp.br (F.K. Miyazawa), yw@ime.usp.br

(Y. Wakabayashi).

0305-0548/$ - see front matter © 2009 Elsevier Ltd. All rights reserved.doi:10.1016/j.cor.2008.12.015

(instead of saying non-oriented orthogonal packing). We also denotethe corresponding problems by dSPr (d-dimensional strip packingproblemwith rotation) and dBPr (d-dimensional bin packing problemwith rotation).

We present approximation algorithms with asymptotic perfor-mance bounds 2.64 and 4.89 for the problems 3SPr and 3BPr, respec-tively.

Approximation algorithms for the oriented versions of these pack-ing problems have been extensively considered. The most studiedcase is the one-dimensional bin packing problem (1BP), for whichthe work of Johnson [3] in the early 1970s pioneered the approach ofdesigning efficient approximation algorithms with worst-case per-formance guarantee for packing problems. Since 1BP is NP-hard andit is a particular case of all problems considered in this paper, itfollows that each problem considered here is NP-hard. Moreover,1BP cannot be approximated—in the absolute sense—within 3

2 − �;thus, this negative result also holds for the problems consideredhere.

In what follows we only mention some previous results closelyrelated to the problems we focus in this paper. For the problem2SP, Kenyon and Rémila [4] obtained an asymptotic polynomialtime approximation scheme (APTAS). For the problem 2BP, Chunget al. [5] proved that the algorithm HFF(p) (Hybrid First Fit) hasasymptotic performance bound 2.125. In 2001, Caprara [6] provedthat this algorithm has asymptotic performance bound 2.077; andalso presented an algorithm with asymptotic performance bound1.691, the best bound known for the problem 2BP. Recently, Bansalet al. [7] proved that there is no APTAS for 2BP, unless P=NP. Theyalso showed an APTAS for the problem dBP when the items and thebins are d-dimensional cubes. For the problem 3SP, in 1997 we pre-sented a 2.67-approximation [8], then in 2006 Jansen and Solis-Oba

2802 F.K. Miyazawa, Y. Wakabayashi / Computers & Operations Research 36 (2009) 2801 -- 2815

[9] obtained a (2+ �)-approximation, and recently Bansal et al. [10]obtained a 1.69-approximation. For the problem 3BP, Li and Cheng[11] and Csirik and van Vliet [12] designed algorithms with asymp-totic performance bound 4.84. Their algorithms generalize to theproblem dBP, and achieve asymptotic performance bound close to1.691d.

The approximation bounds of some of the algorithms designed forthe oriented version may also hold when these algorithms are usedfor the corresponding r-packing problem. This happens when theproofs are based only on area arguments. Except for these cases, notmany results are known on approximation algorithms for r-packingproblems. The interest on these problems is more recent and hasincreased lately.

For the problem 2SPr, the algorithms NFDH and BLDW haveasymptotic performance bound 2 (see [1]). In [13] we presented analgorithm with asymptotic performance bound 1.613; then Epsteinand van Stee [14] obtained an algorithm with asymptotic bound 1.5,and Jansen and van Stee [15] presented an APTAS.

We considered a special case of the problem 3SPr, denoted by3SPz, in which the boxes can be rotated around the z-axis, but can-not be laid down. For this problem we obtained an algorithm withasymptotic performance bound 2.67 (see [16]). We also showed analgorithm with bound 2.55 for the special case of 3SPz in which thebin has square bottom, and also for a more specialized version inwhich the boxes have square bottom (see [13] for a result when thebin does not have a square bottom). To our knowledge, [16] is thefirst paper to present approximation algorithms for r-packing prob-lems where rotations are exploited in a non-trivial way. It is easyto see that any algorithm for 3SPz leads to an algorithm to 2BPr

with the same bound. Therefore, the algorithms presented in [16]also lead to algorithms for the problem 2BPr. For the special case inwhich the bins are squares, Epstein [17] presented an on-line algo-rithm with asymptotic bound 2.45. Using the APTAS presented byJansen and van Stee [15] for the problem 2SPr, it is possible to ob-tain a (2 + �)-asymptotic approximation algorithm for 2BPr, whichis the best result known for this problem. Epstein and van Stee [14]obtained an algorithm with asymptotic bound 2.25 for the specialcase of 3SPz where the bin has square bottom. They also observedthat this algorithm can be used to obtain an algorithm with asymp-totic performance bound 4.5 for the special case when the bins arecubes.

Using the fact that there is no APTAS for 2BP, we may easilyconclude that there is no APTAS for the problem 3SP or 3BP, unlessP= NP.

For a survey on approximation algorithms for packing problems,we refer the reader to [1,18].

This paper is organized as follows. In Section 2, we define theproblems, give some basic definitions and state some results. Sec-tions 3 and 4 are devoted to problems 3SPr and 3BPr, respectively.In Section 5 we present some concluding remarks.

An extended abstract corresponding to an early version ofthis paper appeared in [13], presenting results for the two- andthree-dimensional cases. In that paper, we only mentioned thebounds we have obtained, without any algorithm or proof forthe three-dimensional case. In fact, in the present paper, for the3SP problem we show an algorithm with performance bound2.64, which is better than the bound 2.76, mentioned in thatpaper.

2. Preliminaries

In this section, we first define the packing problems that appearin this paper, then give some basic definitions, establish the nota-tion, and mention some known results that we use. We also dis-cuss some relations (reductions) between algorithms for the oriented

version and the version with rotations. Since we use existing algo-rithms for subproblems of the 3SPr and 3BPr, we also define theseproblems.

In the bin packing problem, 1BP, we are given a list of itemsL = (s1, . . . , sn), and bins B of capacity a, where 0 < si�a, and weare asked to find a packing of L into a minimum number ofbins B.

The two-dimensional strip packing problem with rotation, 2SPr, isthe following: given a list of rectangles L=(r1, . . . , rn), where ri=(xi, yi),and a bin B=(a,∞), find an r-packing of the rectangles of L into B thatminimizes the size of the packing in the unlimited direction of B.

In the two-dimensional bin packing problem with rotation, 2BPr,we are given a list of rectangles L = (r1, . . . , rn), where ri = (xi, yi),and two-dimensional bins B = (a, b), and we are asked to findan r-packing of the rectangles of L into a minimum number ofbins B.

The three-dimensional strip packing problem with rotation, 3SPr,is defined as follows: given a list of boxes L = (e1, . . . , en), whereei = (xi, yi, zi), and a bin B = (a, b,∞), find an r-packing of the boxesof L into B, that minimizes the size of the packing in the unlimiteddirection of B.

In the three-dimensional bin packing problem with rotation, 3BPr,we are given a list of boxes L = (e1, . . . , en), where ei = (xi, yi, zi),and three-dimensional bins B = (a, b, c), and we are asked tofind an r-packing of the boxes of L into a minimum number ofbins B.

We denote by 2SPr(a), 2BPr(a, b), 3SPr(a, b), and 3BPr(a, b, c) thecorresponding problems versionswith the bin sizes defined by valuesa, b and c. If P is a packing for the (three-dimensional) strip packingproblem, we denote by H(P) the height of packing P, and if P is apacking for the (three-dimensional) bin packing problem, we denoteby #(P) the number of bins used in P.

2.1. Definitions and notation

In all problems considered in this paper the given list L ofboxes must be packed orthogonally into bins B (three-dimensionalstrip or three-dimensional bins) in such a way that no two itemsoverlap.

For all algorithms we assume that every item e in the input list Lis given in a feasible orientation, that is, in an orientation that allowsit to be packed into B without the need of any rotation (there isno loss of generality in assuming this, as the items can be rotatedpreviously if needed). Moreover, we consider that the items haveeach of its dimensions not greater than a constant Z.

To refer to the packings, we consider the Euclidean space R3, withthe xyz coordinate system. An item e in L has its dimensions definedas x(e), y(e) and z(e), also called its length, width and height, respec-tively. Each of these dimensions is the measure in the correspondingaxis of the xyz system. For the one- and the two-dimensional cases,some of these values are not defined.

If e is a rectangle then we denote by S(e) its area. If e is a box thenthe bottom area of e is the area of the rectangle (x(e), y(e)), and V(e)denotes the volume of e. Given a function f : C → R and a subsetC′ ⊆ C, we denote by f (C′) the sum

∑e∈C′ f (e).

Although a list of items is given as an ordered n-tuple, when theorder of the items is irrelevant we consider the corresponding listas a set. Therefore, if L is a list of items, we refer to the total area,respectively, volume, of the items in L as S(L), respectively, V(L).

If L1, L2, . . . , Lk are lists, where Li = (e1i , e2i , . . . , e

nii ), the con-

catenation of these lists, denoted by L1‖L2‖ · · · ‖Lk, is the list(e11, . . . , e

n11 , e12, . . . , e

n22 , . . . , e1k , . . . , e

nkk ).

The following is a convenient notation to define and restrict theinput list of items. We assume that the dimensions of the input

F.K. Miyazawa, Y. Wakabayashi / Computers & Operations Research 36 (2009) 2801 -- 2815 2803

bin B is (a, b, c):

X[p, q] := {e : p · a < x(e)�q · a},Y[p, q] := {e : p · b < y(e)�q · b},Z[p, q] := {e : p · c < z(e)�q · c},Cxy [p1, q1 ; p2, q2] :=X[p1, q1] ∩Y[p2, q2],

Cyz [p1, q1 ; p2, q2] :=Y[p1, q1] ∩Z[p2, q2],

Czx [p1, q1 ; p2, q2] :=Z[p1, q1] ∩X[p2, q2],

Cxyz [p1, q1 ; p2, q2 ; p3, q3] :=X[p1, q1] ∩Y[p2, q2] ∩Z[p3, q3],

Cm := Cxyz[0,

1m

; 0,1m

; 0,1m

],

Cxym := Cxy

[0,

1m

; 0,1m

],

Cp,q :=X[0, 1/p] ∩Y[0, 1/q],

Cp,q,r :=X[0, 1/p] ∩Y[0, 1/q] ∩Z[0, 1/r].

℘1 := [ 12 , 1 ; 12 , 1], ℘2 := [0, 12 ; 1

2 , 1],

℘3 := [ 12 , 1 ; 0, 12 ], ℘4 := [0, 12 ; 0, 12 ].

If T is a set of items, then we say that an item e in L is of type Tif e′ ∈T for some permutation e′ of e. If P is a packing, we denoteby L(P) the set of boxes packed in P.

If A is an algorithm (for one of the packing problems), and L is alist of items to be packed, then A(L) denotes the size of the packinggenerated by algorithmAwhen applied to list L, and OPT(L) denotesthe size of an optimal packing of L. The size can be the height of thepacking or the number of bins used in the packing, depending on theproblem we are considering. Although OPT will be used for distinctproblems, its meaning will be clear from the context. We say thatan algorithm A has asymptotic performance bound � if there existsa constant � such that A(L)��OPT(L)+ �, for all input list L.

2.2. Relations between algorithms for oriented packings and r-packings

One way to solve r-packing problems is to adapt algorithms de-signed for the oriented case. In [16] we mention that, for the prob-lem 3SPz, a simple algorithm that first rotates all items so as to havethem in a feasible orientation and applies an algorithm for 3SP musthave an asymptotic bound at least 3. It can be shown, using the samestrategy, that no algorithm for 2SPr, designed as we described above,can have asymptotic performance bound smaller than 2. Similar re-sults also hold for the problems 2BPr and 3BPr: no algorithm withasymptotic performance bound smaller than 3 can be obtained asdescribed above (for more details see [16]).

Most of the results concerning approximation results do not con-sider rotations. In the early 1980s, Coffman et al. [1] discussing thecase where 90◦ rotations are allowed, mentioned that “no algorithmhas been found (for the problem 2BP) that attains improved guar-antees by actually using such rotations itself.” Chung et al. [5] alsodiscussed this matter and raised the question about the possibilityof obtaining algorithms with better worst-case bounds. For otherpapers that raise questions about rotations the reader may refer to[4,19].

We can show that when scaling does not affect the problem, forany of the general packing problems considered, the version allowingrotations is as hard to approximate as the oriented version. Moreprecisely, we can show the following result.

Theorem 2.1. Let PROBr be one of the problems defined previously,for which orthogonal rotations around some of the axes x or y or z(possibly several axes) are allowed; and let PROB be a variant of PROBr,

obtained by fixing the orientation of the packing with respect to someaxis. Let � and �r be constants and Ar an algorithm for PROBr suchthat Ar(L)��OPT(L)+ �r for any input list L of PROBr. Then, there isan algorithm A for PROB such that the following holds:

A(L)��OPT′(L)+ � for any input list L of PROB,

where OPT′(L) is the size of an optimum packing of L (w.r.t. PROB) and� is a constant. Moreover, the reduction is polynomial, if we consider aconvenient representation for the instance.

Proof. Consider the problem 2BPr and an instance composed of aninput list of rectangles L and bins of size B = (a, b). Suppose thatx(e)�a and y(e)�b, for each item e ∈ L. Let Ar be an algorithm for2BPr such that Ar(L)��OPT(L) + �r . Consider the following algo-rithm A′ for the problem 2BP. First take a scaling of B to B′ = (a′, b)and L to L′ in the same proportion, in such a way that min{x(e) : e ∈L′} > b. In this case, all rectangles of L′ can only be packed in the orig-inal orientation. At this point, we apply algorithm Ar to pack L′ intothe box B′, obtaining a packing P′. At last, rescale P′ to the originalsizes, obtaining a packing, say P (of the original list L into B). It isclear that A′(L)�� ·OPT′(L)+ �, where OPT′(L) is the size of an op-timum packing for the problem 2BP and � is the additive constantobtained in the original scale.

For the three-dimensional case, we can first apply the strategyso that no box can be rotated around the z-axis. Then, we apply thesame strategy scaling the height of all boxes and bins in such waythat no item can be laid down. Denote the final input list by L′′ andthe final bins by B′′. Obtain a packing P′′ applying the algorithm A′

and then rescale the packing P′′ to the initial sizes.We can apply the same strategy when rotations are allowed in

only some axes, and design an algorithm A with the desired prop-erty. �

Using the fact that there is no APTAS for the problems 2BP (see[20]) we have the following negative result.

Corollary 2.2. There is no APTAS for the problems 2BPr, 3SPr and 3BPr,unless P = NP.

One-dimensional bin packing problem: Some algorithms we shalldescribe use one-dimensional bin packing problem algorithms assubroutines. This section is devoted to these algorithms and relatedresults (see [18]). Many algorithms have been designed for 1BP. Inwhat follows we describe the following: NF (Next Fit), FF (First Fit)and FFD (First Fit Decreasing).

The algorithm NF can be described as follows. Given a list of itemsL, it packs the items in the order given by L. The first item is packedinto a bin which becomes the current bin; then as long as there areitems to be packed, the next item is tested. If possible, it is packedinto the current bin; if it does not fit in the current bin, then it ispacked into a new bin, which becomes the current bin.

The algorithm FF also packs the items in the order given by L.It tries to pack each new item into one of the previous bins, con-sidering the order they were generated. If it is not possible to packan item in any of the previous bins, the algorithm packs it into anew bin.

The algorithm FFD first sorts the items of L in decreasing orderof their length, and then applies the algorithm FF.

We also use the APTAS designed by Fernandez de la Vega andLueker [18,21], which we denote by FL�.

Theorem 2.3 (Fernandez de la Vega and Lueker [21], Coffman et al.[18]). For any rational � >0, there exists a polynomial-time algorithmFL� for the one-dimensional bin packing problem such that, for any inputlist L, FL�(L)� (1+ �)OPT(L)+ 1.

2804 F.K. Miyazawa, Y. Wakabayashi / Computers & Operations Research 36 (2009) 2801 -- 2815

Two-dimensional strip packing problem: Some of the algorithmswe use as subroutine, are for the two-dimensional strip packingproblem with rotation (2SPr). For the problem 2SP, Coffman et al.[19] presented the algorithms NFDH(s) (Next Fit Decreasing Height)and FFDH(s) (First Fit Decreasing Height) and proved that theirasymptotic performance bounds are 2 and 1.7, respectively. Thealgorithm NFDH(s) first sorts the input list L in decreasing orderof height, then packs the rectangles side by side generating levels.When an item cannot be packed in the current level, it is packedin a new level above the previous one. The algorithm FFDH(s) alsopacks the items in decreasing order of height. Each item is packedin the first level with sufficiently space to accommodate it. If thereis no such level, the item is packed in a new level above theprevious one.

Recently, Jansen and van Stee [15] presented an asymptotic ap-proximation scheme for problems inwhich all items can be packed inboth ways. We note that the scheme presented can also be adaptedto the case in which some of the items may not be rotated.

Theorem 2.4 (Jansen and van Stee [15]). For any rational � >0,there exists a polynomial-time algorithm JvS� for 2SPr(a) such thatJvS�(L)� (1 + �)OPT(L) + O(Z/�2), for any list L of rectangles withdimensions at most Z.

3. Three-dimensional strip packing problem

In this section, we present an algorithm for 3SPr, called TRIk,�,with asymptotic performance bound close to 2.64. We observe thatwe consider the more general setting in which the bin may not havesquare bottom.

This algorithm uses the critical set combination strategy usedin [8,16]. The idea is to combine item types which do not lead topackings with good space filling, if considered independently.

In Section 3.1 we present some subroutines used by the main al-gorithm of this section. In Sections 3.2–3.4 we present the ideas ofthe main algorithm and how they guide us to obtain the main algo-rithm. In Section 3.2 we show a first idea to obtain an approxima-tion algorithm with asymptotic factor 3.25 and the points we needto improve to obtain a better bound. In Section 3.3, we present afirst combination step to obtain an improved algorithm with bound2.6875. In Section 3.4, we consider another combination step to ob-tain the final bound of 2.64. The use of the combination of criticalsets is the key idea of algorithm TRIk,�. In Section 3.5 we present themain algorithm in detail.

3.1. Subroutines

The algorithm TRIk,� uses many algorithms as subroutines, whichwe describe in what follows.

First we describe the algorithm NFDH (Next Fit DecreasingHeight) presented by Li and Cheng [22]. The algorithm has twovariants: NFDHx and NFDHy. The notation NFDH is used to refer toany of these variants.

Algorithm NFDH. The algorithm NFDHx first sorts the boxes of L indecreasing order of their height, say L= (e1, e2, . . . , en). The first boxe1 is packed in the position (0, 0, 0), the next one is packed in theposition (x(e1), 0, 0) and so on, side by side, until a box is found thatdoes not fit in this layer. At this moment the next box ek is packedin the position (0, y(e∗), 0), where y(e∗) =max{y(ei), i = 1, . . . , k − 1}.The process continues in this way until a box el is found that doesnot fit in the first level. Then the algorithm packs this box in a newlevel at the height z(e1). The algorithm proceeds in this way until allboxes of L have been packed.

x

y

Fig. 1. Two stacks of boxes.

The algorithmNFDHy is analogous to the algorithmNFDHx, exceptthat it generates the layers in the y-axis direction (for a more detaileddescription see [22]).

The following result will be useful (see [8,16]).

Lemma 3.1. Let L be an instance of 3SPr and P be a packing of Lconsisting of levels N1, . . . ,Nv such that min{z(e) : e ∈ Ni}� max{z(e) :e ∈ Ni+1}, and S(Ni)� sab for a given constant s >0, i=1, . . . ,v−1. ThenH(P)� (1/s)V(L)/a b+ Z.

If a packing P satisfies the above inequality, we say that P hasa volume guarantee of s.

Given a set of boxes S, we call these boxes as f -boxes if we canobtain a packing of Swith volume guarantee of at least f . For example,the boxes S ⊂ Cxy[ 13 ,

12 ; 1

2 , 1] are 13 -boxes, since we can sort the

boxes in S in non-increasing order of height and place two boxes ineach level, each box b with S(b)�ab/6, except perhaps in the lastlevel. From Lemma 3.1, the obtained packing has volume guarantee13 . Another way to obtain a packing PS of S with volume guarantee13 is to iteratively pack the boxes generating two stacks, from thebottom of the bin, packing the next box of S at the top of the stackwith smallest height. See Fig. 1. When all boxes have been packed,the two stacks have almost the same height, except by a differenceof Z. Since the bottom area of each box is at least ab/6 and theheight difference of the two stacks is at most Z, we can concludethat V(S)�ab/3(H(PS)− Z). Isolating H(PS) we can see that packingPS has a volume guarantee of 1

3 .

Algorithm LL. Another algorithm we use is the algorithm LLm, pre-sented by Li and Cheng [2]. It is used to pack lists L such that L ⊂ Cxy

m .The Algorithm LL first sorts the boxes in L in non-increasing orderof their height and then divides L into sublists L1, . . . , Lv such thatL = L1‖ · · · ‖Lv. Each sublist Li has total bottom area S(Li) that is atleast ((m−2)/m)ab (except possibly for the last sublist) but not morethan ((m−2)/m)ab+ab/m2. Then, it uses a two-dimensional packingsubroutine to pack each sublist into only one level (the subroutineis proved to pack in only one bin if the total area of rectangles isbounded in this way). Clearly, the area occupation in each level is atleast ((m− 2)/m)ab, and using Lemma 3.1 the following holds.

Lemma 3.2 (Li and Cheng [2]). If P is a packing generated by thealgorithm LLm for an instance L ⊂ Cxy

m , then LLm(L)� (m/(m − 2))V(L)+ Z.

Algorithm A3S. Another algorithm we use is the algorithm A3Sp,q,presented in [23]. This algorithm does not use any rotation. It

F.K. Miyazawa, Y. Wakabayashi / Computers & Operations Research 36 (2009) 2801 -- 2815 2805

Fig. 2. (a) Partition of boxes into parts (view of the xy-plane) and (b) rotation of abox with dimensions (10, 5, 7) to a box (5, 7, 10).

divides the input list L ⊂ Cp,q into several sublists and apply specificalgorithms for each one. Each packing is a level-oriented packing inthe conditions presented for Lemma 3.1, with area occupation of atleast (pq/(p+ 1)(q+ 1))ab in each level. The following holds for thisalgorithm.

Lemma 3.3. IfP is a packing generated by the algorithm A3Sp,q for aninstance L ⊆ Cp,q, then A3Sp,q(L)� ((p+ 1)(q+ 1)/pq)V(L)+ 6Z.

Denote by 3Sm the algorithm A3S1/m,1/m. Using Lemma 3.3, thefollowing holds.

Corollary 3.4. If P is a packing generated by the algorithm 3Sm for aninstance L ⊆ Cm,m, then 3Sm(L)� ((m+ 1)/m)2V(L)+ 6Z.

3.2. Idea of the algorithm TRIk,�

First, let us give an idea of the algorithm TRIk,�. Consider the setof boxes defined by the sets ℘1, . . . ,℘4 (mentioned in Section 2.1).Now, consider an input list of boxes for 3SPr(a, b).

(i) First rotate each box e ∈ ℘1 of the input list, if possible, to a boxwith orientation e′ ∈ ℘2 ∪℘3 ∪℘4.

(ii) Now, rotate each remaining box e ∈ ℘1, if possible, to a box withorientation e′ ∈ ℘1 in such a way that z(e′) is minimum.

Fig. 2 illustrates step (i). Let L be the resulting input list, after thesetwo steps and let Li be the set L ∩℘i, for i= 1, . . . , 4.

If we apply algorithmA3Sp,q for sublists L1, . . . , L4 with appropriatevalues of p and q for each sublist, we obtain packings P1, . . . ,P4 forwhich the following holds:

H(P1)�11/4

V(L1)ab+ C1Z, (1)

H(P2)�11/3

V(L2)ab+ C2Z, (2)

H(P3)�11/3

V(L3)ab+ C3Z, (3)

H(P4)�14/9

V(L4)ab+ C4Z, (4)

where Ci, i=1, . . . , 4, are constants. That is, the boxes in the lists L1, L2,L3 and L4 are 1

4 -boxes,13 -boxes,

13 -boxes and 4

9 -boxes, respectively.Note that after steps (i) and (ii) the boxes of L1 can only be packed

one on top of the other, and therefore,

H(P1)= OPT(L1)�OPT(L). (5)

Let n1 = H(P1)− C1Z and n2 =∑4

i=2(H(Pi)− CiZ). Now we havetwo lower bounds for the height of an optimum packing: the heightof packing P1 and the volume based lower bound V(L)/ab. That is,

OPT(L)�H(P1)= n1 (6)

and

OPT(L)�V(L)ab= V(L1)

ab+

4∑i=2

V(Li)ab

�14n1 +

13n2. (7)

From (6) and (7), we have

OPT(L)� max{n1, 14n1 + 13n2}. (8)

Using the above relation, we can prove the following inequality forthe final packing P=P1‖P2‖P3‖P4:

H(P)= H(P1)+ H(P2)+ H(P3)+ H(P4)

= n1 + n2 + CZ

�n1 + n2

max{n1, 14n1 + 1

3n2}OPT(L)+ CZ

= �′ OPT(L)+ CZ,

where C=∑4i=1 Ci and �′ := (n1 + n2)/max{n1, 14n1 + 1

3n2}. The valueof �′ can be bounded by 3.25 using the following lemma, shown in[24].

Lemma 3.5. Suppose X, Y , x, y are real numbers such that x >0 and0 <X <Y <1. Then

x+ ymax{x,Xx+ Yy} �1+ 1− X

Y.

In the analysis we considered that the packing that was generatedconsists of two parts: one optimum packing (P1) with “poor” volumeguarantee (of 1

4 ) and the other part (packing P2‖P3‖P4) with a“medium” volume guarantee (of at least 1

3 ).Note that if we could improve the volume guarantee of 1

4 or 13

that appear in the ratio �′, then we obtain a bound that is better than3.25. So, the first idea used in the algorithm TRIk,� is to use a criticalcombination strategy to improve the volume guarantee of one of theparts. In each combination step, we combine two types of boxes, eachtype associated with a small volume guarantee. Although the boxesof each type may lead to packings with poor volume guarantee, ifpacked separately, the combined packing may have a good volumeguarantee. The arrangement using two types of boxes may have acombination that leads to a better volume occupation than with onlyone type.

For each algorithm, we define the sublists that leads to packingswith poor volume guarantee for each region, denoted as critical boxes,and make a combined packing with good volume guarantee, whichwe denote by good packings.

3.3. Combining critical 13 -boxes with critical 1

3 -boxes

In this section we present the algorithms that combine critical 13 -

boxes: COMBINEz and COMBINE-ABzk. The packing obtained by the

combination step has a good volume guarantee, of at least 0.457.We consider the combination of boxes of type A=A1‖ · · · ‖

Ak+14 with boxes of typeB=B1‖ · · · ‖Bk+14 (throughout the paper,we denote the critical sets with lettered sets or lettered indexes).These sets are illustrated in Fig. 3 and are produced by algorithmCOMBINE-ABz

k. Since this algorithm is also used as a subroutine forproblem 3BPr, it will be described in a more general way.

The combination is performed in steps by combining boxes oftype Ai with boxes of type Bj, for 1� i, j�k + 14. At each combi-nation step, all boxes of type Ai or all boxes of type Bj are totally

2806 F.K. Miyazawa, Y. Wakabayashi / Computers & Operations Research 36 (2009) 2801 -- 2815

Fig. 3. Sublists Ai :=Axyi and Bj :=Bxy

j when a= b= 1.

B

A

A

Fig. 4. Example of a packing produced by algorithm COMBINE with three columns.

packed. Fig. 4 illustrates a packing that combines such boxes. The fi-nal combined packing of boxes of typeA andB is the concatenationof all combined packings.

To describe algorithm COMBINE-ABzk, we have to define some

numberswhich are used to define critical sets. For each critical subsetAi and Bj, we can obtain positions and use the algorithm COMBINEto obtain a combined packing of items of Ai ∪ Bj, such that thevolume guarantee of the combined packing is at least 27

56 and all itemsof one of these critical subsets are totally packed. These numbershave already been used in [8,16]. For completeness, we present themand also the critical sets and related results.

Definition 3.6. Let r(k)1 , r(k)2 , . . . , r(k)k+15 and s(k)1 , s(k)2 , . . . , s(k)k+14 be realnumbers defined as follows:

• r(k)1 , r(k)2 , . . . , r(k)k are such that r(k)112 = r(k)2 (1 − r(k)1 ) = r(k)3 (1 − r(k)2 ) =

· · · = r(k)k (1− r(k)k−1)= 13 (1− r(k)k ) and r(k)1 < 4

9 ;

• r(k)k+1 = 13 , r

(k)k+2 = 1

4 , . . . , r(k)k+15 = 1

17 ;

• s(k)i = 1− r(k)i for i= 1, . . . , k;

• s(k)k+i = 1− ((2i+ 4− (i+ 2)/3�)/(4i+ 10)) for i= 1, . . . , 14;

The following result can be proved using a continuity argument.

Claim 3.7. The numbers r(k)1 , r(k)2 , . . . , r(k)k are such that r(k)1 > r(k)2 > · · · >r(k)k > 1

3 and r(k)1 → 49 as k→∞.

For simplicity, we omit the superscripts (k) of the notation r(k)i , s(k)iwhen k is clear from the context.

Using the numbers in Definition 3.6, we define the followingcritical sets (see Fig. 3):

Axyi =Cxy[ri+1, ri ; 1

2 , si], Bxyi =Cxy[ 12 , si; ri+1, ri],

Axy =k+14⋃i=1

Axyi , Bxy =

k+14⋃i=1

Bxyi .

We use basically the same procedure used in [16] with the algo-rithm COMBINE, with a small modification.

Algorithm COMBINEz. This algorithm is called with the parameters(L,T1,T2,p1, p2), where p1=(p11,p12, . . . , p1n1 ) consists of the positionsin the bottom of box B where the columns of boxes of type T1

F.K. Miyazawa, Y. Wakabayashi / Computers & Operations Research 36 (2009) 2801 -- 2815 2807

should start and p2 = (p21, p22, . . . ,p

2n2 ) consists of the positions in the

bottom of box Bwhere the columns of boxes of typeT2 should start.Each point pij=(xij, yij) represents the x-axis and the y-axis coordinateswhere the first box (if any) of each column of the respective typemust be packed. Note that the z-axis coordinate need not be specifiedsince it may always be assumed to be 0 (corresponding to the bottomof box B). Here we are assuming that the positions p1, p2 and thetypesT1,T2 are chosen in such a way that the defined packing canalways be performed (a column will not intersect any other column).We call height of a column the sum of the height of all boxes in thatcolumn. Initially, all n1+n2 columns are empty, starting at the bottomof box B. At each iteration, the algorithm chooses a column with thesmallest height, say a column given by the position pij, and packs

the next box e of type Ti, updating the list L after each iteration. Ifthere is no such box e, then the algorithm terminates returning thepartial packing P of L.

We denote by COMBINEx and COMBINEy the corresponding ver-sion of the algorithm COMBINEz which generates columns in the xand y directions, respectively, or by COMBINE when considering anyof these versions. The only modification of the algorithm COMBINE,from the version presented in [16], is that it may consider orthogo-nal rotations around any axis, to fit in the sets Axy

i or Bxyj , or any

set (type) given as a parameter. The next lemma is valid for this al-gorithm:

Lemma 3.8 (Miyazawa and Wakabayashi [16]). Let P be the packingof L′ ⊆ L generated by the algorithm COMBINE when applied to lists oftypesT1 andT2 and list of positions pi1, p

i2, . . . ,p

ini , i=1, 2. If S(e)� siab,

for all boxes e inTi (i=1, 2), then H(P)� (1/(s1n1+s2n2))V(L′)/ab+Z.

We also denote the sum s1n1+s2n2, in Lemma 3.8, as the volumeguarantee of the packing P.

To combine all boxes of type Axy or Bxy, we call the algo-rithm COMBINEz with pairs of types Axy

i and Bxyj . Since each

run of algorithm COMBINE packs all boxes of one type, it is suffi-cient to call COMBINE 2(k + 14) times. We denote this algorithmas COMBINE-ABz

k(L, COMBINE). The algorithm COMBINE is givenas a parameter, since in the next section, we use the algorithmCOMBINE-ABz

k to pack boxes into bins for problem 3BPr with an-other subroutine. Fig. 4 illustrates a packing produced by algorithmCOMBINE-AB.

The following lemma is obtained from Lemma 3.8, using the factthat the volume guarantee of packing PAB is at least 17

36 .

Lemma 3.9 (Miyazawa and Wakabayashi [16]). If PAB is a packing ofa list LAB generated by the algorithm COMBINE-ABz

k with parameters(L, COMBINE), then

H(PAB)�1

17/36V(LAB)ab

+ (2k+ 41)Z.

Fig. 5 presents the volume guarantee one can obtain for each re-gion using only list partition without any combination. As the algo-rithm COMBINE-ABz

k packs all boxes of type A or type B, assumethat all boxes of type B have been packed by this routine. Fig. 6 il-lustrates the volume guarantee for the remaining boxes, in each re-gion, and the situation when all boxes of type B have been packed.Now, if possible rotate each box in parts ℘1 ∪℘2 that fits in the set℘3∪℘4. Clearly, after this step there will be no box which, if rotated,becomes a box in the setB, because the construction of packingPABconsiders any possible rotation of boxes in the input list L.

Since the remaining items in℘1∪℘2 cannot be packed side by sidein the y-dimension, we have now an instance of the two-dimensional

Fig. 5. Critical sets A and B.

Fig. 6. After combination of boxes of type A and B: all boxes of type B have beenpacked.

strip packing problem, for which we can obtain an almost optimumpacking (according to Theorem 2.4), and volume guarantee at least14 (minimum of 1

4 and 13 ). To this end, rotate each box e ∈ ℘1 ∪℘2, if

possible, to a box e′ ∈ ℘1 ∪℘2 so that y(e′) is maximum (this allowsto consider each box as a smallest possible rectangle in the xz plane).Therefore, at this point, we can obtain a final packing consisting oftwo parts: one almost optimum packing with volume guarantee 1

4and another (for the remaining boxes) with volume guarantee 4

9 . Inthis case, when � → 0, we can use Lemma 3.5 to obtain a packingwith asymptotic performance bound

h′1 + h′2

max{

11+ �

h′1,14h1 + 4

9h′2

} ≈ 2.6875.

2808 F.K. Miyazawa, Y. Wakabayashi / Computers & Operations Research 36 (2009) 2801 -- 2815

Fig. 7. After combination of LC and LD: LC ⊆PCD .

Fig. 8. After combination of LC and LD: LD ⊆PCD .

3.4. Combining critical 14 -boxes with critical 4

9 -boxes

At this point, we continue with a new combination step, just af-ter the generation of the combination of boxes of typeA andB thatproducedPAB. Now, we combine critical 1

4 -boxes, which are given bythe set LC , and critical 4

9 -boxes, which are given by the set LD=L′D‖L′′D.These critical sets can be seen in Fig. 9. The precise definition of setsLC and LD can be found in the description of Algorithm TRIk,�: theseare the set of boxes of types TC and TD, defined in step 4.3. Thecombined packing has also a good volume guarantee (which is alsoat least 1

4 + 29 = 17

36 =0.472 . . .). Figs. 7 and 8 present the regions of thecritical sets LC and L′D‖L′′D and the status when the boxes of each crit-ical set are totally packed. The fractions indicate the minimum vol-ume guarantee we can obtain for each region. The combined pack-ing PCD is the concatenation of two packings: P′CD, which combinesLC and L′D, and P′′CD, which combines the remaining items of LC andL′′D. The packing P′CDhas one column consisting of items in LC and

one column consisting of items in L′D. The packing P′′CD has one col-umn consisting of items in LC and two columns consisting of itemsin L′′D.

If all critical 14 -boxes have been packed in PCD, we obtain the

following bound:

h′1 + h′2

max{

h′11+ �

, 0.271h1 +49h′2

} .

Otherwise, if all critical 49 -boxes have been packed inPCD we obtain

the following bound:

h′′1 + h′′2

max{

h′′11+ �

,14h′′1 + 0.457h′′2

} .

In both cases, a simple calculation shows that the asymptotic per-formance bound is at most 2.64.

3.5. Description and analysis of algorithm TRIk,�

In this section we present a formal description of algorithm TRIk,�and analyse its asymptotic performance bound. We observe thatthe value of t defined in step 2 was obtained by imposing equal-ity for the bounds obtained in both cases analysed in the proof ofTheorem 3.10.

The algorithm TRIk,� and the proof of its approximation factorfollows very closely the ideas presented in Sections 3.2–3.4. Thepackings obtained with combinations of critical sets have letteredindexes: PAB and PCD. Both packings have good volume guaran-tee (at least 0.47). The remaining boxes are divided into many sub-lists, but basically, the final packing is divided into two parts (seeSection 3.4): one with poor volume guarantee (in Case 1 it is 0.271and in Case 2 it is 0.25) and the other part has a good volume guar-antee (in Case 1 it is 0.444 and in Case 2 it is 0.457). For the partwith poor volume guarantee, we could obtain an almost optimumpacking (one within (1+ �) of the optimum).

Algorithm TRIk,�(L).Input: List of boxes L (instance of 3SP(a, b)).Output: PackingP of L into a bin B=(a, b,∞), allowing orthogonalrotations.

1 Rotate each box e ∈ ℘1, if possible, to a box e′ ∈ ℘2 ∪℘3 ∪℘4.2 t← (

√33− 3)/6.

3 PAB ← COMBINE-ABzk(L, COMBINE). L← L\L(PAB).

4 If all boxes of type Bxyk were packed in PAB then

4.1 Rotate each box e ∈ L∩℘2, if possible, to a box e′ ∈ ℘3∪℘4.4.2 Rotate each box e ∈ L ∩ (℘1 ∪ ℘2), if possible, to a box

e′ ∈ ℘1 ∪℘2 such that y(e) is maximum.4.3 Let

TC =Cxy[ 12 , 1;12 , 1− t], T′D =Cxy [0, t ; 0, 1] ,

T′′D =Cxy [0, t ; 0, 1] , TD =T′D ∪T′′D.

4.4 Generate a packing PCD as follows.PCD′ ← COMBINE(L,TC ,T

′D, [(0, 0)], [(0, 1− t)]).

PCD′′ ← COMBINE(L\LCD′ ,TC ,T′′D, [(0, 0)], [(0, 1 −

t), ( 12 , 1− t)]).

F.K. Miyazawa, Y. Wakabayashi / Computers & Operations Research 36 (2009) 2801 -- 2815 2809

Fig. 9. Sublist after the packing of list LB = (B1 ∪ · · · ∪ Bk+14).

PCD ←PCD′ ‖PCD′′ ;LCD ← LCD′ ∪ LCD′′ ;

4.5 Subdivide the list L into sublists L1, . . . , L23 as follows (seeFig. 9). Li ← L ∩Cxy

[12 , 1 ; 1

i+2 ,1

i+1], i= 1, . . . , 16,

L17 ← L ∩Cxy[ 12 , 1 ; 0, 118 ],

L18 ← L ∩Cxy[ 13 ,12 ; 1

3 ,12 ], L19 ← L ∩Cxy[ 13 ,

12 ; 1

4 ,13 ],

L20 ← L ∩Cxy[ 13 ,12 ; 0, 14 ], L21 ← L ∩Cxy[ 14 ,

13 ; 1

3 ,12 ],

L22 ← L ∩Cxy[0, 14 ; 13 ,

12 ], L23 ← L ∩Cxy[0, 13 ; 0, 13 ].

4.6 Generate packings P1, . . . ,P23 as follows.

Pi ← NFDHy(Li) for i= 1, . . . , 21;

Pi ← NFDHx(Li) for i= 22;

P23 ← LL3(L23).

4.7 Paux ←PAB‖PCD‖P1‖ · · · ‖P23;4.8 L← L\L(Paux). /* Note that L ⊆ ℘1 ∪℘2. */4.9 Consider each box e ∈ L as a rectangle of length x(e) and

height y(e) and the box B= (a, b,∞) as a rectangular stripof length a and unlimited height. Apply algorithm JvS� toL (see Theorem 2.4) and let PJvS be the resulting packing.Let PNFDH be the packing NFDHx(L ∩X[0, 13 ])‖NFDHx(L ∩X[ 13 ,

12 ])‖NFDHx(L ∩X[ 12 , 1]).

Let PSTRIP be the smallest packing in {PJvS,PNFDH}.4.10 P←PSTRIP‖Paux.

5 If all boxes of type Axyk were packed in PAB then generate a

packing P of L as in step 4 in symmetric way.6 Return P.

End algorithm.

Theorem 3.10. For any instance L for the problem 3SPr, we have

TRIk,�(L)��k,� OPT(L)+O

(k+ 1

�

)Z,

where �k,� → (25+ 3√33)/16= 2.639 . . . as k→∞ and �→ 0.

Proof. We present the proof for the case in which all boxes oftype Bxy

k were packed in step 4. The proof for the other case (step5) is analogous. We analyse two subcases, according to step 4.4(LC ⊆ LCD).

Each packing Pi, i ∈ {1, . . . , 23}\{1, 18}, has a volume guaranteeof at least 17

36 . Furthermore, this minimum value is attained wheni ∈ {16, 17}. Therefore, applying Lemmas 3.1 and 3.2 we can concludethat

H(Pi)�3617

V(Li)ab+ Z for i ∈ {1, . . . , 23}\{1, 18}. (9)

From Lemma 3.9, we have

H(PAB)�3617

V(LAB)ab

+ (2k+ 41)Z. (10)

For the packings PCD′ and PCD′′ (step 4.4), the volume guarantee(by Lemma 3.8) is at least 1

4 + r12 , and therefore

H(PCD)�1

14+ r1

2

V(LCD)ab

+ 2Z. (11)

Let us analyse the two possibilities: LC ⊆ LCD or LD ⊆ LCD (seestep 4.4).

2810 F.K. Miyazawa, Y. Wakabayashi / Computers & Operations Research 36 (2009) 2801 -- 2815

Case 1: LC ⊆ LCD. For the packings P1 and P18 we have

H(P1)�1r1

V(L1)ab+ Z, (12)

H(P18)�149

V(L18)ab

+ Z. (13)

By Theorem 2.4,

H(PSTRIP)�H(PJvS)� (1+ �)OPT(LSTRIP)+ ��Z, (14)

where LSTRIP is the set of items packed in PSTRIP. Note that to derivethe last inequality we used the fact that the items in LSTRIP cannot bepacked side by side in the y-direction. Moreover, any item e ∈ LSTRIPhas been previously rotated to have maximum (possible) value ofy(e). So, applying algorithm NFDH to LSTRIP we obtain

H(PSTRIP)�H(PNFDH)�1

(1− t) 12

V(LSTRIP)ab

+ 3Z. (15)

Now, for the packingPaux=PAB‖P1‖ · · · ‖P23, using the inequal-ities (10)–(13) and the fact that r1� min{ 1736 , 14 + r1

2 ,49 }, we obtain

H(Paux)�1r1

V(Laux)ab

+ (2k+ 68)Z, (16)

where Laux denotes the set of boxes in the packing Paux.Let

n1 := H(PSTRIP)− ��Z, (17)

n2 := H(Paux)− (2k+ 68)Z. (18)

From inequality (14) we have n1� (1 + �)OPT(LSTRIP) and there-fore,

OPT(L)�OPT(LSTRIP)�n1

(1+ �). (19)

From (16) and (18) we can conclude that

V(Laux)ab

� r1n2, (20)

and from (15) and (17), we have

V(LSTRIP)ab

�(1− t)

2n1. (21)

Since V(L) = V(Laux) + V(LSTRIP), using (20) and (21) we obtainV(L)/ab� r1n2 + ((1− t)/2)n1.

So,

OPT(L)�V(L)ab

� r1n2 +(1− t)

2n1.

Combining (19) and the inequality above, we get

OPT(L)� max{

11+ �

n1,1− t2

n1 + r1n2

}.

Since H(P)= H(Paux)+ H(PSTRIP); using (17) and (18), we have

H(P)= (n2 + (2k+ 68)+ n1 + ��)= n1 + n2 + (2k+ �′�)Z,

where �′� = �� + 68. Therefore,

TRIk,�(L)��′k,�(r1)OPT(L)+ (2k+ �′�)Z,

where �′k,�(r1)=(n1+n2)/max{(1/(1+�))n1, ((1−t)/2)n1+r1n2t}. Nowusing Lemma 3.5, we can conclude that �′k,�(r1)� [1/r1 − (1− t)(1+�)/2r1 + (1+ �)].

Case 2: LD ⊆ LCD. As the proof of this case is analogous, we omitsome details. Since all rectangles of L′D were packed in PCD, we

have no critical 14 -boxes in L1. More precisely, we have a volume

guarantee of at least t for the packing P1. The same can be verifiedfor the packing P18. Thus, the following holds:

H(Pi)�1tV(Li)ab+ Z for i ∈ {1, 18}. (22)

Since t� min{ 14 + r12 ,

1736 }, from (22), (10) and (11) we have

H(Paux)�1tV(Laux)

ab+ (2k+ 68)Z. (23)

By Theorem 2.4,

H(PSTRIP)�H(PJvS)� (1+ �)OPT(LSTRIP)+ ��. (24)

The packing PNFDH has a volume guarantee of at least 14 and since

H(PSTRIP)�H(PNFDH), we have

H(PSTRIP)�11/4

V(LSTRIP)ab

+ 3Z. (25)

Let

n1 := H(PSTRIP)− ��Z and

n2 := H(Paux)− (2k+ 68)Z.

Then, from (24) we can conclude that

OPT(L)�OPT(LSTRIP)�1

1+ �n1.

Now, from (23) and (25), we have

V(Laux)ab

� tn2 andV(LSTRIP)

ab�

14n1,

and therefore,

OPT(L)�V(L)ab

� tn2 +14n1.

So,

OPT(L)� max{

11+ �

n1,14n1 + tn2

}.

Thus, TRIk,�(L)��′′k,�(r1)OPT(L)+(2k+�′�)Z, where �′′k,�(r1)� [1/t−(1+�)/4t + (1+ �)]. The last inequality follows by taking �′′k,�(r1)= (n1 +n2)/max{(1/(1+ �))n1, 14n1 + tn2} and using Lemma 3.5.

From both cases above, we can conclude that for k → ∞ and�→ 0 the statement of the theorem holds. �

4. Three-dimensional bin packing problem

In this section, we consider the three-dimensional bin packingproblem with rotation (3BPr). We present an algorithm with anasymptotic performance bound that may converge to a value smallerthan 4.89. We denote the algorithm of this section by BOXk,�.

4.1. Subroutines

Before presenting the main algorithm, we describe some algo-rithms used as subroutines.

Algorithm H3B. This algorithm uses the same strategy used in thealgorithm HFF (Hybrid First Fit) presented by Chung et al. [5]. Thealgorithm H3Bz generates a packing in two steps. First it generates athree-dimensional strip packing of L, subdivided in levels and usingthe z-axis as a height dimension, and then packs the levels intobins, using a one-dimensional bin packing algorithm. The algorithms

F.K. Miyazawa, Y. Wakabayashi / Computers & Operations Research 36 (2009) 2801 -- 2815 2811

for the problems 3SP and 1BP used in these steps must be givenas subroutines. We denote by H3Bp,q,r the algorithm that uses thealgorithms A3Sp,q and FFD as subroutines and by H3Bm the algorithmH3B1/m,1/m,1/m. The following holds for this algorithm.

Lemma 4.1 (Miyazawa and Wakabayashi [25]). If P is a packinggenerated by the algorithm H3Bp,q,r for an instance L ⊆ Cp,q,r , thenH3Bp,q,r(L)� ((p+ 1)(q+ 1)(r + 1)/pqr)V(L)+ 14.

Lemma 4.2. If P is a packing generated by the algorithm H3Bm for aninstance L ⊆ Cm, then H3Bm(L)� ((m+ 1)/m)3V(L)+ 14.

Denote by H3Dx and H3Dy the variants of this algorithm wherethe generation of levels is done in the x and y direction, respectively.

Algorithm FFDC. We use the same scheme of the algorithmCOMBINE used for 3SPr. For that, we first modify the algorithmCOMBINE to the bin packing version. We denote this algorithm asFFDCz (First Fit Decreasing Combine for z-axis). The algorithm FFDCz

combines the strategy of the algorithm COMBINE with the strategyof the algorithm FFD to pack boxes into columns.

The input parameters are a list of boxes L, two set of boxes T1and T2 and two coordinate lists p1 and p2 associated with thesesets. Each column starts at the bottom of a box B in a coordinatep ∈ p1 ∪ p2. The columns located in coordinates of list [pi] have onlyboxes of type Ti, i = 1, 2, and start in the plane xy growing in thedirection of the z-axis.

Algorithm FFDCz.Input: (L,T1,T2,p1,p2) // each pi is a list of coordinates in theplane xy.Output: Partial packing of L into B such that all boxes of type T1or all boxes of type T2 are totally packed.

1 While there are non-packed boxes in L of typeT1 andT2 do1.1 Let P1,P2, . . . ,Pi be the packings in the bins B1, . . . ,Bi,

respectively, generated so far.1.2 Take a non-packed box e′ of typeT1 with z(e′) maximum.

If possible, pack e′ in a column of boxes correspondingto T1 in P1, . . . ,Pi, without violating the limits of thecorresponding bin. If necessary, rotate the box e′ so as tohave e′ ∈T1.

1.3 If it is not possible to pack a box in step 1.2, pack (ifpossible) the next box e′′, of type T2, using the samestrategy used in step 1.2, but with columns of boxes oftype T2.

1.4 If it was not possible to pack an item by steps 1.2 and1.3, let i← i+1; generate a new empty packing Pi (thatstarts with empty columns in positions p1 ∪ p2) in a newbin Bi.

2 Return P1,P2, . . . ,Pi.

end algorithm.

We denote by FFDCx and FFDCy the corresponding versions of thealgorithm FFDCz that generates columns in the x and y directions,respectively.

4.2. Main algorithm for 3BPr

Now, we present the ideas behind the algorithm BOXk,�. To un-derstand this algorithm, we first consider the volume guaranteeone could obtain if only list partition and the next fit decreasing

algorithms were used. Suppose we partition the region of boxes intypes Tijk, for i, j, k ∈ {0, 1} as follows:

X0 ←X[0, 12 ], X1 ←X[ 12 , 1],

Y0 ←Y[0, 12 ], Y1 ←Y[ 12 , 1],

Z0 ←Z[0, 12 ], Z1 ←Z[ 12 , 1],

Tijk ←Xi ∩Yj ∩Zk, i, j, k ∈ {0, 1}.

First, rotate each box e ∈ L of type T111, if possible, to a box e′ ∈∪ijk�111Tijk. Now, consider the volume guarantee one can obtainwith Lemma 4.1, only with list partition and algorithm H3B. PartitionL into sets Sijk := L ∩Tijk, for i, j, k ∈ {0, 1}. We have the followingvolume guarantees for each sublist:

• In the set S111 we have the larger items. Since S111 = L∩X[ 12 , 1]∩Y[ 12 , 1] ∩Z[ 12 , 1], we have that Sijk ⊆ C1,1,1. From Lemma 3.2 wehave that

H3B1,1,1(S111)�(1+ 1)(1+ 1)(1+ 1)

1 · 1 · 1 V(S111)+ 14

= 11/8

V(S111)+ 14.

Therefore, the set S111 leads to the very poor volume guarantee of18 . The analysis for other sublists are similar.

• For the boxes in Sijk, with i + j + k = 2, we can obtain a volumeguarantee of 1

21223 = 1

6 = 0.166 . . . .• For the sets Sijk, with i+j+k=1, we can obtain a volume guarantee

of 122323 = 2

9 = 0.222 . . . .• For the set S000, we can obtain a packing with a volume guarantee

of 232323 = 8

27 = 0.296 . . . .

The critical sets defined for algorithm BOXk,� consider regions forwhich we obtain volume guarantee close to 1

8 (in set S111), 16 (in sets

S011, S101 and S110) and 29 (in sets S001, S010 and S100). Since no two

boxes of S111 can be packed in a same bin, placing one box of S111in each bin leads to an optimum packing of S111. Therefore, usingLemma 3.5, we can obtain a packing with asymptotic performancethat is bounded by

n1 + n2

max{n1,

18n1 +

16n2

} �6.25.

In the next sections, we define and combine critical sets to obtainpackings with better bounds.

4.2.1. Combining critical 16 -boxes with critical 1

6 -boxesThe algorithm first combines critical sets of type Tijk, with i +

j+ k= 2, using the algorithm COMBINE-ABk with subroutine FFDC.First, it combines critical 1

6 -boxes of typeT011 andT101 obtain-ing a combined packing with a good volume guarantee. If all criti-cal boxes of type T011 have been packed, it combines critical boxesof type T101 with critical boxes of type T110; otherwise, it com-bines critical boxes of type T011 with critical boxes of type T110.In each combination step, it defines the corresponding critical sets.To combine critical boxes of type T011 and T101, it uses the rou-tine COMBINE-ABz

k with subroutine FFDCz. See Fig. 11(a). Note thatall boxes e ∈T011∪T101 have z(e) > c

2 and each bin produced in thecombined packing has three boxes, except perhaps in the last, withtotal bottom area at least 17

36ab. Therefore, the volume guarantee ofthis combined packing is at least 17

3612 = 17

72 =0.231 . . . . The same vol-ume guarantee can be obtained when critical 1

6 -boxes of typesT011and T110 are combined. Denote by PAB the packing produced bycalling algorithm COMBINE-ABk.

2812 F.K. Miyazawa, Y. Wakabayashi / Computers & Operations Research 36 (2009) 2801 -- 2815

Before continuing with new combination steps, let us give theidea behind the direction of these combinations. After the generationof packingPAB, we can obtain packings with volume guarantee closeto 2

9 = 0.222 . . . for the remaining boxes, except for those in T110 ∪T111. Fortunately, if each box e ∈T110∪T111 is previously rotatedto a box e′ ∈ Tijk, for ijk /∈ {110, 111}, the remaining items in L ∩(T110∪T111) can only be packed side by side in the z-axis. Therefore,it is an instance of a one-dimensional bin packing problem, for whichwe can obtain an almost optimum packing (see Theorem 2.3) andvolume guarantee of at least 1

8 . This leads to a final packing withasymptotic performance bound

n1 + n2

max{

11+ �

n1,18n1 +

29n2

} �4.9375.

We can obtain a further improvement with some more combi-nations.

4.2.2. Combining critical 18 -boxes with critical 2

9 -boxesAssume that all critical 1

6 -boxes of types T011 and T101 havebeen totally packed. So, the current situation is the following: Thepacking PAB has volume guarantee at least 17

72 and the remainingboxes in the set T011 and T101 lead to packings with volume guar-antee close to 17

72 . The last combination steps consider the critical 18 -

boxes, in the set T111, and the critical 29 -boxes in

⋃ijk /∈{111,000}Tijk.

The combined packing of this step, denoted by PCD, has good vol-ume guarantee (that is at least p

2 = 0.225 . . .) and totally packs oneof the critical sets. See Figs. 11(b) and (c). We have two cases, de-pending on which critical set is totally packed:

Case 1: All critical 29 -boxes are totally packed. In this case, the

asymptotic performance bound is at most

n1 + n2

max{

11+ �

n1,18n1 +

p2n2

} .

Case 2: All critical 18 -boxes are totally packed. In this case, the

asymptotic performance bound is at most

n1 + n2

max{

11+ �

n1,1− p4

n1 +29n2

} .

In both cases, the performance bounds is close to 4.882. The valueof p was obtained in such a way that the two cases give the samebound.

4.2.3. Algorithm BOXk,�The Algorithm BOXk,� and the proof of its approximation factor

follows the ideas presented in Section 4.2. As before, the packingsobtained with combination of critical sets have lettered indexes:PABandPCD, since the ideas used are close to the ones used in algorithmTRIk,�. The volume guarantees we can obtain for the bin packing caseare worse than those for the strip packing version. So, in this casewe say that a good volume guarantee, obtained for packingsPAB andPCD, is close to 0.236. The final packing is divided into two parts,one with poor volume guarantee (in Case 1 it is 0.125 and in Case 2it is 0.137) and the other part with good volume guarantee (in Case1 it is 0.225 and in Case 2 it is 0.222). Here we could also obtainan almost optimum packing (within (1+ �) of the optimum) for theitems in the part with poor volume guarantee.

We present now a formal description of the algorithm we ex-plained previously.

Fig. 10. Lists Lijk .

Algorithm BOXk,�(L).Input: List of boxes L (instance of 3BPr(a, b, c)).Output: Packing P of L into bins B= (a, b, c).

1 Let

X0 ←X[0, 12 ], X1 ←X[ 12 , 1],

Y0 ←Y[0, 12 ], Y1 ←Y[ 12 , 1],

Z0 ←Z[0, 12 ], Z1 ←Z[ 12 , 1];

Tijk ←Xi ∩Yj ∩Zk, ijk ∈ {0, 1}.

2 p←√137−96 .

3 Rotate each box e ∈ L ∩T111, if possible, in such a way thate fits in one of the sets Tijk, ijk�111. Ties can be decidedarbitrarily.

4 P′AB ← COMBINE-ABzk(L,T011,T101, FFDCz); L ← L\L(P′AB);

If all boxes of type T011 ∩Axyk were packed then

P′′AB ← COMBINE-ABxk(L,T101,T110, FFDCx);

Otherwise // all boxes of type T101 ∩Bxyk were packed. //

P′′AB ← COMBINE-AByk(L,T110,T011, FFDCy);

PAB ←P′AB ∪P′′AB; (L← L\L(P′′AB);5 Consider that all boxes of type (T011∩Axy

k ) and (T101∩Ayzk )

were totally packed.5.1 Rotate each box e ∈ L of type T110, if possible, to a box

e′ ∈Tijk, for some ijk /∈ {111, 110}.5.2 Rotate each box e ∈ L of type T110 ∪T111, if possible, to

a box e′ ∈T110 ∪T111 such that z(b) is minimum.5.3 Let Lijk ← L ∩Tijk for i, j, k ∈ {0, 1} (see Fig. 10).5.4 P000 ← H3D2(L000).5.5 Generate a packing PCD in the following manner.

P011CD ← FFDCz(L011∪L111,T011∩X[ 13 ,p],T111∩X[ 12 , 1−

p], [(0, 0)], [(0,p)]);

F.K. Miyazawa, Y. Wakabayashi / Computers & Operations Research 36 (2009) 2801 -- 2815 2813

B A

A

CD C

D

D

Fig. 11. Example of bins: (a) bin of packing PAB; (b) bin with boxes of types T011 ∩X[ 13 , p] and T111 ∩X[ 1

2 , 1 − p]; (c) bin with boxes of types T010 ∩Z[ 13 ,

12 ] ∩X[ 1

3 , p]and T111 ∩X[ 1

2 , 1− p].

L111 ← L111\L(P011CD ; (See Fig. 11(b))

P101CD ← FFDCx(L101∪L111,T101∩Y[ 13 ,p],T111∩Y[ 12 , 1−

p], [(0, 0)], [(0,p)]);L111 ← L111\L(P101

CD ;P001

CD ← FFDCz(L001 ∪ L111,T001 ∩X[ 13 ,12 ] ∩Y[ 13 , p],

T111 ∩Y[ 12 , 1− p], [(0, 0), (0, 12 )], [(0,p)]);L111 ← L111\L(P001

CD ;P010

CD ← FFDCy(L010 ∪ L111,T010 ∩Z[ 13 ,12 ] ∩X[ 13 , p],

T111 ∩X[ 12 , 1− p], [(0, 0), (0, 12 )], [(0,p)]);L111 ← L111\L(P010

CD ; (See Fig. 11(c))P100

CD ← FFDCx(L100∪L111,T100∩Y[ 13 ,12 ]∩Z[ 13 ,p],T111∩

Z[ 12 , 1− p], [(0, 0), (0, 12 )], [(0,p)]);L111 ← L111\L(P100

CD ;PCD ←P011

CD ∪P101CD ∪P001

CD ∪P010CD ∪P100

CD .5.6 Generate packings of the remaining boxes of the sublists

Lijk with i+ j+ k= 1.5.6.1 Generate a packing P001 of the remaining boxes in

L001 in the following manner. Let L18001, . . . , L23001 be a

partition of L001 such that (see Fig. 9).L18001 ← L001 ∩Cxy[ 13 ,

12 ; 1

3 ,12 ],

L19001 ← L001 ∩Cxy[ 13 ,12 ; 1

4 ,13 ],

L20001 ← L001 ∩Cxy[ 13 ,12 ; 0, 14 ],

L21001 ← L001 ∩Cxy[ 14 ,13 ; 1

3 ,12 ],

L22001 ← L001 ∩Cxy[0, 14 ; 13 ,

12 ],

L23001 ← L001 ∩Cxy[0, 13 ; 0, 13 ].

Pi001 ← H3Dz(NFDHy, Li001, NF), i= 18, . . . , 21;

P22001 ← H3Dz(NFDHx, L22001, NF);

P23001 ← H3Dz(BI(t)3 , L23001, NF);

P001 ←P18001 ∪ · · · ∪P25

001.5.6.2 Generate a packing P010 of the remaining boxes of

L010 in a way analogous to step 5.6.1, generatingthe levels in the y-axis direction.

5.6.3 Generate a packing P100 of the remaining boxes ofL100 in a way analogous to step 5.6.1, generatingthe levels in the x-axis direction.

5.7 Generate a packing of the remaining boxes of L011 andL101.5.7.1 Generate a packing P011 of the remaining boxes of

L011. Let (L1011, . . . , L17011) be a partition of L011 defined

as follows (see Fig. 9).

Li011 ← L011 ∩Y[1

i+ 2,

1i+ 1

], i= 1, . . . , 16;

L17011 ← L011 ∩Y[0, 118 ];

Pi011 ← H3Dxy(NFDHy, Li011, NF), i= 1, . . . , 17;

P011 ←P1011 ∪ · · · ∪P17

011.5.7.2 Generate a packing P101 of the remaining boxes of

L101 in a way analogous to step 5.7.1, consideringthe plane yz instead of xy.

5.8 Generate a packing of the remaining boxes of L110 andL111 as follows.5.8.1 LUNI ← L110 ∪ L111;5.8.2 Consider each box e of LUNI as a one-dimensional

item of length z(e) and each bin B as a one-dimensional bin with length c.

5.8.3 P′UNI ← FFDz(LUNI);5.8.4 P′′UNI ← FLz�(LUNI);5.8.5 PUNI ← (P ∈ {P′UNI,P′′UNI}|#(P) is minimum).

5.9 Paux ←PAB ∪PCD ∪P000 ∪P001 ∪P010 ∪P100 ∪P011 ∪P101;

5.10 P←PUNI ∪Paux.6 For the other cases, the steps are analogous to step 5, differing

only in the planes and directions the packing is generated.7 Return P.

end algorithm.

The next result shows a bound for the asymptotic performanceof algorithm BOXk,�.

Theorem 4.3. For any list of boxes L for 3BPr, we have

BOXk,�(L)��k,�OPT(L)+ �k,�,

where �k,� → (43 + 3√137)/16 = 4.882 . . . as k→∞ and �→ 0; and

�k,� is a constant that depends on k and �.

Proof. First, denote by L′ijk the boxes packed in the packing Pijk, fori, j, k ∈ {0, 1}. We analyse two cases, considering the set M, defined as

M := L111 ∩X[ 12 , 1− p] ∩Y[ 12 , 1− p] ∩Z[ 12 , 1− p],

after step 5.5.

In what follows, for a packing Q we denote by b_area(Q) thefraction of the bottom area of the bin B that is occupied by thepacking Q .

Case 1: M� ∅ after step 5.5.By Lemma 4.2 we have

#(P000)�1

8/27V(L′000)abc

+ 14. (26)

2814 F.K. Miyazawa, Y. Wakabayashi / Computers & Operations Research 36 (2009) 2801 -- 2815

For the packingPAB, we have a b_area(PAB)� 1736 , except perhaps

in 2(2k+ 41) bins. Since each box of LAB has height greater than c/2,we have

#(PAB)�1

17/72V(LAB)abc

+ 4k+ 82. (27)

For the packing PCD, note that for each bin B of PiCD, i ∈

{011, 101, 001, 010, 100}, we have b_area(PiCD)�

14 + r1

2 , except per-

haps for the last bin of each packing PiCD. Also considering that each

box has height greater than c/2, we have

#(PCD)�1

18+ r1

4

V(LCD)abc

+ 6. (28)

For the packing P001, for each bin B of Pi001, we have a

b_area(Pi001)�

1736 . Note that the boxes with small area guarantee

in L18001 were totally packed in PCD, otherwise we would not haveM� ∅. Therefore, proceeding in the same way as before, we have

#(P001)�1

17/72V(L′001)abc

+ 8. (29)

The same analysis we have made for packing P001 can be madefor the packings P010 and P100. So, the following inequalities hold:

#(P010)�1

17/72V(L′010)abc

+ 8, (30)

#(P100)�1

17/72V(L′100)abc

+ 8. (31)

Now, consider the packingP011. Note that for each packingPi011

we have b_area(Pi001)�p (this minimum is attained for list L1011),

except perhaps in the last bin of the packing Pi011. Therefore,

#(P011)�1p/2

V(L′011)abc

+ 17. (32)

In the same way, we have the following inequality for packingP101:

#(P101)�1p/2

V(L′101)abc

+ 17. (33)

From inequalities (26)–(33) and considering that p2=min{ p2 , 1772 , 18+

r14 }, we have

#(Paux)�1p/2

V(Laux)abc

+ Ckaux. (34)

Finally, consider the packing PUNI generated for boxes of L110and L111 in step 5.8. The minimum volume in each bin B of P′UNI,except perhaps in the last bin, is at least abc/8. Therefore,

#(P′UNI)�11/8

V(LUNI)abc

+ 1.

Note that after the rotation of boxes made in step 5.1, there is nobox e in LUNI that can be rotated such that e fits in one of the typesTijk, ijk /∈ {110, 111}. So, after step 5.2, all boxes of LUNI will have thesmallest height possible, without leaving T110 ∪T111. Therefore,after applying algorithm FL� in step 5.8.4, we have

#(P′′UNI)� (1+ �)OPT(LUNI)+ C�UNI.

Since #(PUNI)� max{#(P′UNI), #(P′′UNI)}, we have

#(PUNI)�11/8

V(LUNI)abc

+ 1, (35)

#(PUNI)� (1+ �)OPT(LUNI)+ C�UNI. (36)

From inequalities (34) to (36), we can conclude that

#(P)��′k,�OPT(L)+ �k,�,

where �′k,� = (h1 + h2)/max{ 11+�h1,

18h1 + p

2h2} and �k,� = Ckaux + C�

UNI.Case 2: M = ∅ after step 5.5.The analysis is analogous to Case 1, and the details will be omitted.

We can conclude that

#(P000)�1

8/27V(L000)abc

+ 14,

#(PAB)�1

17/72V(LAB)abc

+ 4k+ 82,

#(PCD)�1

18+ r1

4

V(LCD)abc

+ 6.

Furthermore, for each packing Pi001 we have b_area(Pr

001)�49 . This

also holds for the packings P010 and P100. Therefore, we have

#(P001)�12/9

V(L′001)abc

+ 8,

#(P010)�12/9

V(L′010)abc

+ 8,

#(P100)�12/9

V(L′100)abc

+ 8.

For the packingPi011, we have b_area(Pi

011)� r1. The same also holdsfor packing P101. Therefore,

#(P011)�1

r1/2V(L′011)abc

+ 17,

#(P101)�1

r1/2V(L′101)abc

+ 17.

From the above inequalities, we have

#(Paux)�1

r1/2V(Laux)abc

+ Ckaux.

Since M ⊆ L111 and the boxes of M were totaly packed, we havethat the minimum volume of any box in L111 is at least (1 − p)/4.Therefore, considering the packings of P110 and P111, we have

#(PUNI)�1

(1− p)/4V(LUNI)abc

+ 1.

#(PUNI)� (1+ �)OPT(LUNI)+ C�UNI.

So, we obtain

#(P)��′′k,�OPT(L)+ �k,�,

where �′k,� = (h1 + h2)/max{(1/(1+ �))h1, ((1− p)/4)h1 + (r1/2)h2} and�k,� = Ck

aux + C�UNI.

Let �k,� := max{�′k,�,�′′k,�}. As for k → ∞ we have r1 → 49 ,

we can conclude from both cases above that limk→∞,�→0�k,� �

4.882 . . . . �

F.K. Miyazawa, Y. Wakabayashi / Computers & Operations Research 36 (2009) 2801 -- 2815 2815

5. Concluding remarks

We presented approximation algorithms for three-dimensionalpacking problems where orthogonal rotations are allowed. Weshowed that these problems—in their general version—are as hardto approximate as the oriented case. In this case, any approxi-mation algorithm for the case with rotations can be used to ob-tain an approximation algorithm for the oriented case with thesame approximation bound. The two approximation algorithmsfor three-dimensional packing problems presented in this papercan be implemented to run in time polynomial in the number ofitems.

References

[1] Coffman EG, Garey Jr. MR, Johnson DS. Approximation algorithms for binpacking—an updated survey. In: Ausiello G, Lucertini M, Serafini P, editors.Algorithms design for computer system design. New York: Springer; 1984.p. 49–106.

[2] Li K, Cheng K-H. Static job scheduling in partitionable mesh connected systems.Journal of Parallel and Distributed Computing 1990;10:152–9.

[3] Johnson DS. Near-optimal bin packing algorithms. PhD thesis, MassachusettsInstitute of Technology, Cambridge, MA; 1973.

[4] Kenyon C, Rémila E. A near-optimal solution to a two-dimensional cutting stockproblem. Mathematics of Operations Research 2000;25:645–56.

[5] Chung FRK, Garey MR, Johnson DS. On packing two-dimensional bins. SIAMJournal on Algebraic and Discrete Methods 1982;3:66–76.

[6] Caprara A. Packing 2-dimensional bins in harmony. In: Proceedings of the 43rdsymposium on foundations of computer science. 2002. p. 490–9.

[7] Bansal N, Correa JR, Kenyon C, Sviridenko M. Bin packing inmultiple dimensions: inapproximability results and approximation schemes.Mathematics of Operations Research 2006;31(1):31–49.

[8] Miyazawa FK, Wakabayashi Y. An algorithm for the three-dimensional packingproblem with asymptotic performance analysis. Algorithmica 1997;18(1):122–44.

[9] Jansen K, Solis-Oba R. An asymptotic approximation algorithm for 3D-strippacking. In: Proceedings of the 17th annual ACM-SIAM symposium on discretealgorithms. 2006. p. 143–52.

[10] Bansal N, Han X, Iwama K, Sviridenko M, Zhang G. Harmonic algorithm for 3-dimensional strip packing problem. In: Proceedings of the of the 18th annualACM-SIAM Symposium on discrete algorithms. 2007. p. 1197–206.

[11] Li K, Cheng K-H. A generalized harmonic algorithm for on-line multidimensionalbin packing. TR UH-CS-90-2, University of Houston; January 1990.

[12] Csirik J, van Vliet A. An on-line algorithm for multidimensional bin packing.Operations Research Letters 1993;13:149–58.

[13] Miyazawa FK, Wakabayashi Y. Packing problems with orthogonal rotations. In:Proceedings of the 6th Latin American theoretical informatics, Buenos Aires,Argentina, Lecture notes in computer science, vol. 2976. Berlin: Springer; 2004.p. 359–68.

[14] Epstein L, van Stee R. This side up!. ACM Transactions on Algorithms2006;2(2):228–43.

[15] Jansen K, van Stee R. On strip packing with rotations. In: Proceedings of the37th ACM symposium on theory of computing. 2005.

[16] Miyazawa FK, Wakabayashi Y. Approximation algorithms for the orthogonalz-oriented 3-D packing problem. SIAM Journal on Computing 2000;29(3):1008–29.

[17] Epstein L. Two dimensional packing: the power of rotation. In: Proceedings ofthe 28th international symposium of mathematical foundations of computerscience, Lecture notes on computer science, vol. 2747. Berlin: Springer; 2003.p. 398–407.

[18] Coffman EG, Garey Jr. MR, Johnson DS. Approximation algorithms for binpacking: a survey. In: D. Hochbaum, editor, Approximation algorithms for NP-hard problems, PWS, 1997. p. 46–93 [chapter 2].

[19] Coffman EG, Garey Jr. MR, Johnson DS, Tarjan RE. Performance bounds forlevel oriented two-dimensional packing algorithms. SIAM Journal on Computing1980;9:808–26.

[20] Bansal N, Sviridenko M. New approximability and inapproximability results for2-dimensional bin packing. In: Proceedings of the 15th ACM-SIAM symposiumon discrete algorithms. 2004. p. 189–96.

[21] Fernandez de la Vega W, Lueker GS. Bin packing can be solved within 1+ � inlinear time. Combinatorica 1981;1(4):349–55.

[22] Li K, Cheng K-H. On three-dimensional packing. SIAM Journal on Computing1990;19:847–67.

[23] Miyazawa FK, Wakabayashi Y. Two- and three-dimensional parametric packing.Computers and Operations Research 2007;34:2589–603.

[24] Miyazawa FK, Wakabayashi Y. Parametric on-line algorithms for packingrectangles and boxes. European Journal of Operational Research 2003;150:281–92.

[25] Miyazawa FK, Wakabayashi Y. Cube packing. Theoretical Computer Science2003;297:355–66.