Geometry Meets Vectors: Approximation

Algorithms for Multidimensional Packing

∗ ∗
Arindam Khan Eklavya Sharma K. V. N. Sreenivas ∗

Abstract
We study the generalized multidimensional bin packing problem (GVBP) that generalizes
arXiv:2106.13951v1 [cs.DS] 26 Jun 2021

both geometric packing and vector packing. Here, we are given n rectangular items where
the ith item has width w(i), height h(i), and d nonnegative weights v1 (i), v2 (i), . . . , vd (i).
Our goal is to get an axis-parallel non-overlapping packing of the items into square bins
so that for all j ∈ [d], the sum of the j th weight of items in each bin is at most 1. This
is a natural problem arising in logistics, resource allocation, and scheduling. Despite being
well studied in practice, surprisingly, approximation algorithms for this problem have rarely
been explored.
We first obtain two simple algorithms for GVBP having asymptotic approximation ratios
6(d + 1) and 3(1 + ln(d + 1) + ε). We then extend the Round-and-Approx (R&A) framework
[3, 6] to wider classes of algorithms, and show how it can be adapted to GVBP. Using
more sophisticated techniques, we obtain better approximation algorithms for GVBP, and
we get further improvement by combining them with the R&A framework. This gives us
an asymptotic approximation ratio of 2(1 + ln((d + 4)/2)) + ε for GVBP, which improves to
2.919 + ε for the special case of d = 1. We obtain further improvement when the items are
allowed to be rotated. We also present algorithms for a generalization of GVBP where the
items are high dimensional cuboids.

1 Introduction
Bin packing and knapsack problems are classical NP-hard optimization problems. Two classical
generalizations of these problems: geometric packing and vector packing have been well-studied
from the 1980s [14, 17]. Geometric packing considers the packing of rectangular items, whereas,
in vector packing items are multidimensional vectors. Fig. 1 illustrates the difference between
geometric packing and vector packing. However, often in practice, we encounter a mixture of
geometric and vector constraints. Consider the following airlines cargo problem [37]: We have
boxes to load in an airline cargo container. In addition to the geometric constraint that all the
boxes must fit within the container, we also have a constraint that the total weight of the loaded
boxes is within a specified capacity. Thus, in this problem, three dimensions are geometric and
the weight is a vector constraint.
Weight has been an important constraint to consider for packing in logistics and supply
chain management, e.g., cranes and other equipment can be damaged by the bins being too
heavy, or by a skewed weight distribution [1]. While the container loading problems mostly
consider packing items inside a container, the container stowage planning problem considers
the stacking of the containers onto and off cargo ships [36]. Even when different cargoes are
packed into a fleet of aircraft for transport, one needs the individual cargoes to be not too heavy
to ensure stability and less fuel consumption [2]. Similar problems find applications in vehicle
routing with loading constraints [8]. Many practical heuristics [41, 43] have been proposed for
Department of Computer Science and Automation, Indian Institute of Science, Bengaluru, India.
∗

[email protected], [email protected], [email protected]

1
 0.4
0.4 0.4

0.4
0.4 0.4

0.2 0.2 0.4

0.8 0.8

Figure 1: Geometric & vector packing: We can pack rectangles (0.8, 0.2), (0.4, 0.4), (0.4, 0.4)
into unit geometric bin but can’t pack vectors (0.8, 0.2), (0.4, 0.4), (0.4, 0.4) into unit vector
bin.

these kinds of problems. Several companies (such as Driw, Boxify, Freightcom) and practical
packages [46] have considered the problem. In many cases, we also want to ensure a limit on
other attributes, such as the amount of magnetism, radioactivity, or toxicity. Each of these
properties can be considered as additional vector dimensions.
Such multidimensional packing problems are also getting attention due to their connections
with fair resource allocation [38]. In recent years, a considerable amount of research has focused
on group fairness [27, 44] such that the algorithms are not biased towards (or against) some
groups or categories. One such notion of fairness is restricted dominance [7], which upper bounds
the number (or size) of items from a category. These different categories can be considered as
dimensions. E.g., in a container packing problem for flood relief, one needs to ensure that
the money spent on a container is fairly distributed among different types of items (such as
medicine, food, garments). Hence, for each category, there is an upper bound on the value that
can go into a container.
Formally, we are given n items I := {1, 2, . . . , n} that are (dg , dv )-dimensional, i.e., item
i is a dg -dimensional cuboid of lengths ℓ1 (i), ℓ2 (i), . . . , ℓdg (i) and has dv non-negative weights
v1 (i), v2 (i), . . . , vdv (i). A (dg , dv )-dimensional bin is a dg -dimensional cuboid of length 1 in each
geometric dimension and weight capacity 1 in each of the dv vector dimensions. A feasible
packing of items into a bin is a packing where items are packed parallel to the axes without
overlapping, and for all j ∈ [dv ], the sum of the j th weight-dimension of the items in the bin is
at most 1. In the (dg , dv ) bin packing problem (BP), we have to feasibly pack all items into
the minimum number of bins. In the (dg , dv ) knapsack problem (KS), each item i also has an
associated nonnegative profit p(i), and we have to feasibly pack a maximum-profit subset of the
items into a single bin (also called ‘knapsack’). (dg , dv ) packing problems generalize both dg -
dimensional geometric packing (when dv = 0) and dv -dimensional vector packing (when dg = 0).
Already for vector packing, if dv is part of the input, there is an approximation hardness of
dv 1−ε unless NP=ZPP [5]. Thus, throughout the paper we assume both dg , dv to be constants.

1.1 Our Results

We study the first approximation algorithms for general (dg , dv ) BP, with a focus on dg = 2. We
give two simple algorithms for (2, d) BP, called simple-pack and better-simple-pack, having
asymptotic approximation ratios (AARs) of 6(d + 1) and 3(1 + ln(d + 1)) + ε, respectively, for
any ε > 0. For d = 1, better-simple-pack’s AAR improves to ≈ 4.216 + ε.
Next, we modify the Round-and-Approx (R&A) framework [6] so that it works for (dg , dv )
BP. We combine R&A with the simple-pack algorithm to get an AAR of 2(1 + ln(3(d + 1))) + ε
for (2, d) BP. This improves upon the AAR of better-simple-pack for d ≥ 3.
Next, we obtain a more sophisticated algorithm for (2, d) BP, called cb-pack, that fits into
the R&A framework and has an even better AAR.

Theorem 1. For any ε > 0, there is a polynomial-time algorithm for (2, d) BP, called cb-pack,

2
having AAR 2(1 + ln((d + 4)/2)) + ε (improves to 2(1 + ln((d + 3)/2)) + ε when items can be
rotated by 90◦ ). For d = 1, the AAR improves to 2(1 + ln(19/12)) + ε ≈ 2.919 + ε (further
improves to 2(1 + ln(3/2)) + ε ≈ 2.811 + ε when items can be rotated).

Table 1: Comparison of asymptotic approximation ratios (AARs) of algorithms for (2, d) BP.

(2, d) BP (2, 1) BP
simple-pack 6(d + 1) 12
better-simple-pack 3(1 + ln(d + 1)) + ε 3(1 + ln(3/2)) + ε ≈ 4.216 + ε
simple-pack with R&A 2(1 + ln(3(d + 1))) + ε 2(1 + ln 6) + ε ≈ 5.5835 + ε
cb-pack (without rotation) 2(1 + ln( d+4
2 )) + ε 2(1 + ln(19/12)) + ε ≈ 2.919 + ε
d+3
cb-pack (with rotation) 2(1 + ln( 2 )) + ε 2(1 + ln(3/2)) + ε ≈ 2.811 + ε

We also show how to extend simple-pack and better-simple-pack to (dg , dv ) BP to obtain

AARs 2b(dv + 1) and b(1 + ln(dv + 1) + ε), respectively, where b := 4dg + 2dg . We also give a
similar algorithm for (dg , dv ) KS having approximation ratio b(1 + ε).

1.2 Related Work

The bin packing problem (BP) has been the cornerstone of approximation algorithms [26]. The
standard performance measure for BP algorithms is the asymptotic approximation ratio (AAR).
An asymptotic polynomial time approximation scheme (APTAS) for BP was given by Fernandez
de la Vega and Lueker [17], using linear grouping. Note that 1-D BP can be considered as (1,
0) BP as well as (0, 1) BP. The present best approximation algorithm for 1-D BP returns a
packing in at most opt +O(log opt) bins, where opt is the optimal number of bins [23]. Knapsack
problem (KS) is one of Karp’s 21 NP-complete problems. Lawler gave an FPTAS [34] for KS.
For surveys on BP and KS, we refer the readers to [13, 28].
In [17], a (d+ ε)-asymptotic approximation algorithm was given for the d-dimensional vector
bin packing (d-D VBP). Chekuri and Khanna gave a O(log d) approximation for d-D VBP [11].
The study of 2-D geometric bin packing (2-D GBP) was initiated by [14]. Caprara gave a
T∞d−1 -asymptotic approximation Harmonic-Decreasing-Height (HDH) algorithm for d-D GBP

[9], where T∞ ≈ 1.6901. This is still the best known approximation for d-D GBP for d ≥ 3.
Both 2-D GBP and 2-D VBP were shown to be APX-hard [4, 45].
Bansal, Caprara and Sviridenko [3] introduced the Round-and-Approx (R&A) framework
to obtain improved approximations for both 2-D GBP and d-D VBP. The R&A framework is
a two stage process. First, a (possibly exponential-sized) set covering LP relaxation (called
configuration LP) is solved approximately. Then, a randomized rounding procedure is applied
for a few steps to pack a subset of items, after which only a ‘small’ fraction of items (called the
residual instance) remain unpacked. In the second step, the residual instance is packed using a
subset-oblivious algorithm. Intuitively, given a random subset S of I where each element occurs
with probability about 1/k, a ρ-approximate subset-oblivious algorithm produces a packing
of S in approximately ρ opt(I)/k bins. In the R&A framework, one can obtain a (1 + ln ρ)-
approximation algorithm using a ρ-approximate subset oblivious algorithm. Two algorithms,
1-D BP APTAS [17] and HDH [9] were shown to be subset-oblivious based on various properties
of dual-weighting functions. This led to an AAR of (1+ln(1.69)) and (1+ln d) for 2-D GBP and
d-D VBP, respectively. However, it was cumbersome to extend subset-obliviousness to wider
classes of algorithms.
Bansal and Khan [6] later extended the R&A framework for 2-D GBP to rounding-based
algorithms, where the large dimensions are rounded up to O(1) values and the packing of
items is container-based, i.e. each bin contains a constant number of rectangular regions called
containers and items are packed in a special way into containers. For 2-D GBP, they used a

3
1.5-asymptotic-approximation algorithm [24] to obtain the present best (1 + ln 1.5) ≈ 1.405-
asymptotic-approximation. For d-D VBP, Bansal et al. [5] used the R&A framework combined
with a multi-objective budgeted matching problem, to obtain the present best AAR of (0.81 +
od (1) + ln d).
Multidimensional knapsack is also well-studied. For d-D vector knapsack (d-D VKS), Frieze
and Clarke gave a PTAS [18]. For 2-D geometric knapsack (GKS), Jansen and Zhang [25] gave
a 2-approximation algorithm, while the present best approximation ratio is 1.89 [20]. It is not
even known whether 2-D GKS is APX-hard or not. There are many other related important
geometric packing problems, such as strip packing [21, 19] and maximum independent set of
rectangles [31]. For surveys on multidimensional packing, see [12, 30].

1.3 Technical Contribution

One of our main contributions is the enhancement of R&A framework [6] to wider applications.
First, R&A framework now also works with (dg , dv )-dimensional items, unifying the ap-
proach for geometric and vector packing. To use R&A, we need to solve the configuration LP of
the corresponding bin packing problem. All previous applications (d-D VBP and 2-D GBP) of
R&A solved the configuration LP within (1 + ε) factor using a (1 + O(ε))-approximate solution
to KS. Due to the unavailability of a PTAS for (2, d) KS, we had to adapt and use a different
linear programming algorithm [40] that uses an η-approximation algorithm for KS to (1 + ε)η-
approximately solve the configuration LP of the corresponding BP problem, for any constants
1 < η, 0 < ε < 1.
Second, we introduce more freedom in choosing the packing structure. Unlike the R&A
framework in [6] that worked only for container-based packing, we allow either relaxing the
packing structure to non-container-based (like in simple-pack) or imposing packing constraints
in addition to being container-based (like in cb-pack). This generalization can help in finding
better algorithms for other variants of BP.
Finally, we allow rounding items in ways other than rounding up, if we can find a suitable
way of unrounding a packing of rounded items. In cb-pack, we round down the width and
height of some items to 0, and in simple-pack, we round each (2, d)-dimensional item i to an
item of width 1, height x and each vector dimension x, where x is a value depending on the
original dimensions of i. As it was shown in [30], if the large coordinates of items are rounded
to O(1) types, we cannot obtain better than d and 4/3-approximation for d-D VBP and 2-D
GBP, respectively. However, as we now allow rounding down, we may be able to use the R&A
framework with algorithms having better approximation ratios.
We also fix a minor error in the R&A framework of [30] (see Appendix E.1 for details).
In [3], it was mentioned: “One obstacle against the use of R&A for other problems is the
difficulty in deriving subset-oblivious algorithms (or proving that existing algorithms are subset
oblivious).” We expect that our progress will help in understanding the power of R&A to extend
it to other set-cover type problems, e.g. round-SAP and round-UFP [16].
Our another major contribution is handling of the (2, d) BP problem. This problem presents
additional challenges over pure geometric BP, and our algorithm cb-pack demonstrates how to
circumvent those challenges. For example, in geometric packing, items having low total area can
be packed into a small number of bins using the Next-Fit-Decreasing-Height (NFDH) algorithm
(see [14] and Lemmas 9 and 10 in Appendix A). This need not be true when items have weights,
since the geometric dimensions can be small but the vector dimensions may be large. To handle
this, we divide the items into different classes based on density (i.e., weight/area). We use the
facts that items of low density and low total area can be packed into a small number of bins,
and items of high density that fit into a bin have low total area. Also, in geometric packing, we
can sometimes move items with similar geometric dimensions across different bins (like in linear

4
grouping [17, 39]). Vector dimensions again create problems here, since the items can have
very different weights. To handle this, we only move items of similar geometric dimensions and
density. This leads to a more structured packing and we show how to find such a near-optimal
structured packing efficiently.

2 Preliminaries and Notation

A valid packing of a given set of (dg , dv )-dimensional items into a (dg , dv )-dimensional bin is
an arrangement of the items in the bin such that: (i) All items are packed in an axis parallel
manner, i.e., each item has its faces parallel to the faces of the bin. Formally, to pack an item i
into a bin, we need to decide its position (x1 (i), x2 (i), . . . , xdg (i)) in the bin, and the item will be
Qdg
packed in the cuboidal region j=1 [xj (i), xj (i) + ℓj (i)]. (ii) The items are non-overlapping, i.e.,
the interiors of any two items do not intersect. Formally, for any two items i1 and i2 in the same
Qdg Qdg
bin, the sets j=1 (xj (i1 ), xj (i1 ) + ℓj (i1 )) and j=1 (xj (i2 ), xj (i2 ) + ℓj (i2 )) do not intersect. (iii)
All items are packed completely inside the bin, i.e., for each item i and each j ∈ [dg ], xj (i) ≥ 0
and xj (i) + ℓj (i) ≤ 1. (iv) The total weight packed in each of the dv vector dimensions is at
most one.
Let P be a minimization problem and let I denote the set of all input instances of P.
Consider a polynomial-time approximation algorithm A for P. For any input I ∈ I, let opt(I)
denote the cost of the optimal solution and let A(I) denote the cost of A’s output on I. Then
the quantity

A(I)
ρA := sup
I∈I opt(I)

is called the approximation ratio of A and the asymptotic approximation ratio (AAR) of A is
defined as
 
∞ A(I)
ρA := lim sup opt(I) = z .
z→∞ I∈I opt(I)

Intuitively, AAR denotes the algorithm’s performance for inputs whose optimum value is large.
Let [n] := {1, 2, . . . , n}. Let poly(n) be the set of polynomial and sub-polynomial functions
Qdg
of n. Define vmax , vol, and span as follows: vmax (i) := maxdj=1 v
vj (i), vol(i) := j=1 ℓj (i),
span(i) := max(vol(i), vmax (i)). span(i) is, intuitively, the measure of largeness of item i ∈ [n].
For convenience, let v0 (i) := vol(i). Assume w.l.o.g. that vol(i) = 0 implies (∀j ∈P[dg ], ℓj (i) = 0).
For a set I of items, given := i∈S f (i). This
P a function f : I 7→ R, for S ⊆ I, define f (S)
means, e.g., vol(S) := i∈S vol(i). For any bin packing algorithm A, let A(I) be the resulting
bin packing of items I, and let |A(I)| be the number of bins in A(I). Define opt(I) as the
minimum number of bins needed to pack I.

Lemma 2. For (dg , dv ) items I, ⌈span(I)⌉ ≤ (dv + 1) opt(I).

Proof. Let there be m bins in an optimal packing of (dg , dv )-dimensional items I. In this
optimal packing, let Jj be the items in the j th bin. Then
     
Xm X m XX
X dv m X
X dv
dv
⌈span(I)⌉ = 
 max vj (i)
≤
 vj (i) 
≤ 1
 = (dv + 1)m
k=1 i∈Jk j=0  k=1 i∈Jk j=0  k=1 j=0 

For dg = 2, let w(i) := ℓ1 (i), h(i) := ℓ2 (i) be the width and height of item i, respectively.
The area of item i is a(i) := w(i)h(i) = vol(i). The items in (2, 0) BP are called ‘rectangles’.

5
2.1 Configuration LP
For a bin packing instance I containing n items, a configuration of I is a packing of a subset
of items of I into a bin (see Fig. 2). We denote the set of all configurations of I by C. The
configuration matrix of I is a matrix A ∈ {0, 1}n×|C| where A[i, C] is 1 if configuration C contains
item i and 0 otherwise. To solve the bin packing problem, it is sufficient to decide the number
of bins of each configuration. This gives us the following linear programming relaxation, called
a configuration LP:
X
min xC where Ax ≥ 1 and x ≥ 0
x∈R|C|
C∈C

A feasible solution x to the configuration LP is a vector in R|C| , and |C|, the number of configu-
rations, can be exponential in n. But if | support(x)| ∈ poly(n), then x may have a polynomial-
sized representation.

0.6
0.5
1 0.4 1
0.3
0.2 0.2 0.2 0.2
0.3 0.4

0.4 0.4 0.5 0.5

1.0
0.9
0.8 0.8
0.6
0.4

Configuration 1 Configuration 2 Configuration 3

Figure 2: Top row contains four (2, 2)-dimensional items (histograms show vector
dimensions). Three configurations are shown below it. Placing all items into one bin would
violate both geometric and vector constraints. Placing the green item in configuration 3
violates vector constraints.

3 Simple Algorithms
In this section, we look at simple algorithms for (2, d) BP. They are based on Steinberg’s
algorithm for rectangle packing [42], which has the following corollary:

Lemma 3 (Proof in Appendix B). Let I be a set of rectangles where a(I) ≤ 1. Then there is
a O(n log2 n/ log log n)-time algorithm to pack I into 3 square bins of side length 1.

Let I be a (2, d) BP instance. Let Ib := {span(i) : i ∈ I}, i.e., Ib is a 1-D BP instance. The
algorithm simple-pack(I) first runs the Next-Fit algorithm on I. b Let [Jb1 , Jb2 , . . . , Jbm ] be the
b b b
resulting bin packing of I into m bins. For each Jj ⊆ I, let Jj be the corresponding items from
I. Then ∀k ∈ [dv ], vk (Jj ) ≤ 1 and vol(Jj ) ≤ 1. simple-pack then uses Steinberg’s algorithm to
pack each Jj into at most 3 bins, giving a packing of I into at most 3m bins. By the property
of Next-Fit (see Claim 8 in Appendix A), we get that m ≤ ⌈2 span(I)⌉. By Lemma 2, we get
3 ⌈2 span(I)⌉ ≤ 6(d + 1) opt(I). This gives us the following theorem.

Theorem 4. For (2, d) BP, simple-pack uses at most 3 ⌈2 span(I)⌉ bins, so simple-pack is
a 6(d + 1)-approximation algorithm. simple-pack runs in O(nd + n log2 n/ log log n) time.

6
 The algorithm better-simple-pack first computes I, e which is a (d + 1)-D VBP instance
obtained by replacing the geometric dimensions of each item i ∈ I by a single vector dimension
a(i). It computes a bin packing of Ie using any algorithm A. It then uses Steinberg’s algorithm
to obtain a bin packing of I into at most 3|A(I)|e bins.
Note that opt(I)e ≤ opt(I). If A has AAR α, then |A(I)| e ≤ α opt(I) e + O(1). Therefore,
better-simple-pack has AAR 3α. The (d + 1)-D VBP algorithm by [3] (parametrized by a
constant ε > 0) gives α = 1+ln(d+1)+ε and the algorithm by [5] gives α = 1.5+ln((d+2)/2)+ε
(improves to α = 1 + ln(1.5) + ε for d = 1).
Using similar ideas, we can get an algorithm for (2, d) KS (see Appendix D).
Although simple-pack has a worse AAR than better-simple-pack, the number of bins
used by simple-pack is upper-bounded in terms of span, which is a useful property. Because
of this, we will use it as a subroutine in other algorithms (like cb-pack).
The algorithms for (2, d) packing can be extended to (dg , dv ) packing. We just need an
algorithm for the following problem: given a set J of dg -dimensional cuboids where vol(J) ≤ 1,
pack J into a small number of bins. We used Steinberg’s algorithm when dg = 2. When dg = 3,
we can use the algorithm of [15, Section 2] to pack J into at most 9 bins. For dg > 3, we
can use a variant of the HDH4 algorithm [10] to pack J into at most 4dg + 2dg bins (details in
Appendix C). Therefore, simple-pack will use b ⌈2 span(I)⌉ bins, where b := 3 when dg = 2,
b := 9 when dg = 3, and b := 4dg + 2dg when dg > 3. Therefore, simple-pack is 2b(dv + 1)-
approximate. Similarly, better-simple-pack has AAR b(1 + ln(dv + 1) + ε).

4 Round-and-Approx Framework
We enhance the R&A framework as a general outline for designing approximation algorithms
for the generalized bin packing problem. We denote the algorithm for the R&A framework as
rna-pack(I, β, ε), which takes as input a set I of (dg , dv )-dimensional items and parameters
β ≥ 1 and ε ∈ (0, 1). The steps of the algorithm are as follows (see Algorithm 1 for a more
formal description).

Algorithm 1 rna-pack(I, β, ε): Computes a bin packing of I. I is a set of (dg , dv )-dimensional

items and β ≥ 1
1: b = solve-config-lp(I)
x
2: repeat T := ⌈(ln β)kb xk1 ⌉ times
3: Select a configuration C with probability x bC /kb
xk1 .
4: Pack a bin according to C.
5: end repeat
6: Let S be the unpacked items from I. // S is called the set of residual items.
7: Initialize Jbest to null.
8: e D) ∈ round(I) do
for (I, // round(I) outputs a set of pairs.
9: JD = simple-pack(S ∩ D)
10: Let π be a bijection from I − D to I. e Let Se := {π(i) : i ∈ S − D}.
11: e
J = complex-pack(S) e
12: J = unround(Je)
13: if Jbest is null or |JD ∪ J| < |Jbest | then
14: Jbest = JD ∪ J
15: end if
16: end for
17: Pack S according to Jbest .

7
 1. Solve the Configuration LP of I. Let x b be a µ-asymptotic-approximate solution to the
b corresponds to a configuration. In all previous
configuration LP. Note that each index of x
applications of the R&A framework, µ = 1 + ε. However, in some of our applications we
will have µ to be a large constant.

2. Randomized rounding of configuration LP: For T := ⌈(ln β)kb xk1 ⌉ steps do the
following: select a configuration C with probability xbC /kb
xk1 . Pack T bins according to
each of these selected T configurations. Let S be the remaining items that are not packed,
called the residual instance.

3. Rounding of items: We define a subroutine round that takes items I and parameter
ε as input1 . It discards a set D ⊆ I of items such that span(D) ≤ ε span(I) and then
modifies each item in I − D to get a set Ie of items. We say that the output of round(I, ε)
e D), where items in Ie are called rounded items. Intuitively, after rounding, the items
is (I,
in Ie are of O(1) types, which makes packing easier. Also, since span(D) is small, D ∩ S
can be packed into a small number of bins using simple-pack.
We impose some restrictions on round, which we denote as conditions C1 and C2, that
we describe in Section 4.2. Previous versions of R&A only allowed modifications where
each item’s dimensions were rounded up. We do not have this restriction; we also allow
rounding down some dimensions. We also allow round to output a O(poly(n))-sized list
e D).
of guesses of (I,

4. Pack rounded items: Let Se be the rounded items corresponding to S \ D. Pack Se into
bins using any bin packing algorithm that satisfies ‘condition C3’, which we describe in
Section 4.3. Let us name this algorithm complex-pack.

5. Unrounding: Given a bin packing of S, e let unround be a subroutine that computes

a bin packing of S \ D. unround is trivial in previous versions of R&A, because they
only increase dimensions of items during rounding. In our applications, we may round
down items, so unround can be non-trivial. unround can be any algorithm that satisfies
‘condition C4’, which we describe in Section 4.4.

We can think of the R&A framework as a meta-algorithm, i.e., we give it the algorithms
round, complex-pack and unround as inputs and it outputs the algorithm rna-pack. The R&A
framework requires that round, complex-pack and unround satisfy four conditions C1, C2, C3,
C4, which we describe in Sections 4.2, 4.3 and 4.4. Prospective users of the R&A framework
need to design these three subroutines and prove that they satisfy these four conditions.
Intuitively, rna-pack first packs some items into T bins by randomized rounding of x b. We
can prove that Pr[i ∈ S] ≤ 1/β, so S contains a small fraction of the items in I (see Lemma 5).
We will then try to prove that if the rest of the algorithm (round + complex-pack + unround)
packs I into m bins, then it will pack S into roughly m/β bins. This notion was referred to in
[3] as subset-obliviousness. We will use subset-obliviousness to bound the AAR of rna-pack.
 
Lemma 5. ∀i ∈ I, Pr(i ∈ S) ≤ exp − kbxTk ≤ β1 .
1

Proof. Let C1 , C2 , . . . , CT be the configurations chosen during randomized rounding (line 3 in

1
The input to round is I instead of S because S is random and we want to round items deterministically, i.e.,
the rounding of each item i ∈ S should not depend on which other items from I lie in S. In fact, this is where
the old R&A framework [30] introduced an error. See Appendix E.1 for details.

8
Algorithm 1). Let Ci be the configurations that contain the element i.
T
! T
^ Y
Pr(i ∈ S) = Pr (Ct 6∈ Ci ) = Pr(Ct 6∈ Ci ) (all Ct are independent)
t=1 t=1
   T
T
Y X X x
1 − bC 
= Pr(Ct = C) = 1 −
t=1
kb
xk1
C∈Ci C∈Ci
 T
1
≤ 1− (constraint in configuration LP for item i)
kb
xk1
 
T 1
≤ exp − ≤
kbx1 k β

Section 4.6 shows how to break simple-pack into round, complex-pack and unround and
use it with R&A.

4.1 Fractional Structured Packing

Let (I,e D) be an output of round(I) and let X e be an arbitrary subset of I. e Our analysis of
rna-pack is based around a concept called fractional structured packing of X. e Note that the
notion of fractional structured packing only appears in the analysis of rna-pack. It is not needed
to describe any algorithm.
First, we discuss the notion of structured packing. Several types of packings are used in
bin packing algorithms, such as container-based [24], shelf-based (e.g. output of Caprara’s
HDH algorithm [10]), guillotine-based [22], corridor-based [20], etc. A type of packing is called
to be a structured packing if it satisfies downward closure, i.e., a structured packing remains
structured even after removing some items from the packed bins. For example, Jansen and
Prädel [24] showed that given any packing of a 2-D GBP instance into m bins, we can slice
some of the items and repack them into (1.5 + ε)m + O(1) bins such that the resulting packing
is container-based. Container-based roughly means that in each bin, items are packed into
rectangular regions called containers, and containers’ heights and widths belong to a fixed set
of O(1) values. Hence, container-based is an example of a structured packing as a container-
based packing of bins remains a container-based packing, even if we remove some items from the
packed bins. In fact, all the commonly used packing types are indeed structured packings. Also
note that the set of all possible packings is trivially a structured packing. Our R&A framework
gives algorithm designers the freedom to use or define the structured packing in any way they
want, as long as they satisfy the downward closure property. Typically, the choice of which
definition of structured packing to use will depend on the ease of proving Conditions C2 and
C3 for that definition. This helped us to go beyond the R&A framework of Bansal and Khan
[6], which only considered container-based packings of I. e
Intuitively, a fractional structured packing is one where we slice each item of X e into pieces
e
and then find a structured packing of the pieces. Define fsopt(X) as the number of bins used
in the optimal fractional structured packing of X. e To analyze the AAR of rna-pack, we will
bound the number of bins used to pack the residual instance S in terms of fsopt(S), e and then
e
we will bound fsopt(S) in terms of opt(I).
To define fractional structured packing, we first define what it means to slice an item. From
a geometric perspective, slicing an item perpendicular to the kth dimension means cutting the
item into 2 parts using a hyperplane perpendicular to the kth axis. The vector dimensions get
split proportionately across the slices. E.g., for dg = 2, if k = 1 for item i, then we slice i using
a vertical cut, and if k = 2, we slice i using a horizontal cut.

9
Definition 1 (Slicing an item). Let i be a (dg , dv )-dimensional item. Slicing i perpendicular
to geometric dimension k with proportionality α (where 0 < α < 1) is the operation of replacing
i by two items i1 and i2 such that: (i) ∀j 6= k, ℓj (i) = ℓj (i1 ) = ℓj (i2 ), (ii) ℓk (i1 ) = αℓk (i) and
ℓk (i2 ) = (1 − α)ℓk (i), (iii) ∀j ∈ [dv ], vj (i1 ) = αvj (i) ∧ vj (i2 ) = (1 − α)vj (i).

Definition 2 (Fractional packing). Let Ie be (dg , dv )-dimensional items, where for each item
e we are given a set X(i) of axes perpendicular to which we can repeatedly slice i (X(i)
i ∈ I,
can be empty, which would mean that the item cannot be sliced). If we slice items as per their
given axes and then pack the slices into bins, then the resulting packing is called a fractional
bin packing.

See Fig. 3 for an example of a fractional packing.

0.4
1 + 0.4

0.5 0.5 0.4

✂

0.4 0.4 0.5

Figure 3: Example of a fractional packing of two items into a bin.

4.2 Properties of round

Definition 3 (Density vector). The density vector of a (dg , dv )-dimensional item i is the
vector vspan := [v0 (i)/span(i), v1 (i)/span(i), . . . , vdv (i)/span(i)]. Recall that v0 (i) := vol(i) and
note that kvspan k∞ = 1.

e D). Condition C1 is defined

The subroutine round(I) returns a set of pairs of the form (I,
e D):
as the following constraints over each pair (I,

• C1.1. Small discard: D ⊆ I and span(D) ≤ ε span(I).

• C1.2. Bijection from I − D to I: e Each item in Ie is obtained by modifying an item in

I − D. Let π be the bijection from I − D to Ie that captures this relation.

• C1.3. Homogeneity properties: round partitions items in Ie into a constant number of

e 1, K
classes: K e2, . . . , K
e q . These classes should satisfy the following properties, which we
call homogeneity properties:

– All items in a class have the same density vector.

– For each class K e j , we decide the set X of axes perpendicular to which we can slice
items in Ke j . If items in a class K e j are not allowed to be sliced perpendicular to
dimension k, then all items in that class have the same length along dimension k.
(For example, if dg = 2 and vertical cuts are forbidden, then all items have the same
width.)

• C1.4. Bounded expansion: Let C be any configuration of I and K e be any one of the
e e
classes of I. Let C := {π(i) : i ∈ C − D}. Then we need to prove that span(Ke ∩ C)
e ≤ cmax
for some constant cmax . Let us call this result ‘bounded expansion lemma’.

Intuitively, the homogeneity properties allow us to replace (a slice of) an item in a fractional
packing by slices of other items of the same class. Thus, while trying to get a fractional packing,

10
we can focus on the item classes, which are constant in number, instead of focusing on the n
items. Intuitively, the bounded expansion lemma ensures that we do not round up items too
much.
Condition C2 (also called structural theorem): For some constant ρ > 0 and for some
e
(I, D) ∈ round(I), fsopt(I)e ≤ ρ opt(I) + O(1).
Intuitively, the structural theorem says that allowing slicing as per round and imposing a
structure on the packing does not increase the minimum number of bins by too much. The
AAR of rna-pack increases with ρ, so we want ρ to be small.

4.3 complex-pack
Condition C3: For some constant α > 0 and for any (I, e D) ∈ round(I) and any X e ⊆ I,e
e packs X
complex-pack(X) e into at most α fsopt(X)e + O(1) bins.
Condition C3 says that we can find a packing that is close to the optimal fractional structured
packing. The AAR of rna-pack increases with α, so we want α to be small.

4.4 unround
Condition C4: For some constant γ > 0, if complex-pack(S) e outputs a packing of Se into m
bins, then unround modifies that packing to get a packing of S − D into γm + O(1) bins.
Intuitively, condition C4 says that unrounding does not increase the number of bins by too
much. The AAR of rna-pack increases with γ, so a small γ is desirable. If round only increases
the dimensions of items, then unrounding is trivial and γ = 1.

4.5 AAR of R&A

Recall that simple-pack is a 2b(dv +1)-approximation algorithm for (dg , dv ) BP (see Section 3),
where b := 3 when dg = 2, b := 9 when dg = 3, b := 4dg + 2dg when dg > 3, and b := 1 when
dg = 1. Our key ingredient in the analysis of R&A is the following lemma. We give a sketch of
the proof here and defer the full proof to Appendix E.

Lemma 6. Let Se be as computed by rna-pack(I, β, ε). Then with high probability, we get
e ≤ fsopt(I)/β
fsopt(S) e + 2bµε opt(I) + O(1/ε2 ).

Proof sketch. Our proof of Lemma 6 is inspired by the analysis in [30]. We prove it by analyzing
e
the fractional structured configuration LP of I.
e D) ∈ round(I). Suppose round partitioned Ie into classes K
Definition 4. Let (I, e1, K
e2, . . . K
eq.
e
Let Cf be the set of all structured configurations of items in I that allow items to be sliced
as per round. For any Se ⊆ I, e the fractional structured configuration LP of S,
e denoted as
e
fsconfigLP(S), is
X
min xC
|Cf |
x∈R C∈Cf
X
where e j )xC ≥ span(Se ∩ K
span(C ∩ K e j ) ∀j ∈ [q]
C∈Cf
xC ≥ 0 ∀C ∈ Cf

e The optimal objective values of

The integer version of this program is denoted as fsconfigIP(S).
e and fsconfigIP(S)
fsconfigLP(S) e are denoted as fsconfigLP (S)
∗ e and fsconfigIP∗ (S),
e respectively.

11
 Intuitively, fsconfigIP is the same as the structured fractional bin packing problem because
of the downward closure property, so fsconfigIP∗ (S) e = fsopt(S)
e 2 . By the homogeneity property
(C1.3), the number of constraints in this LP is a constant q. So by rank lemma3 , we can show
e − fsconfigLP∗ (S)|
that | fsopt(S) e ∈ O(1) (see Lemmas 13 and 14 in Appendix E). Now to prove
Lemma 6, roughly, we need to show that fsconfigLP∗ (S) e / fsconfigLP∗ (I)/β.
e
The RHS in the j th constraint of fsconfigLP(S)e is a random variable span(Se ∩ K e j ). The RHS
e is span(K
in the j th constraint of fsconfigLP(I) e j ). Note that E(span(Se ∩ Ke j )) ≤ span(K)/β
e
by Lemma 5. In fact, we can harness the randomness of S, e the bounded expansion property
(C1.4), and a concentration inequality [35], to show that span(Se ∩ K) e / span(K)/β.
e Therefore,
∗ e ∗
if x is an optimal solution to fsconfigLP(I), then x /β is roughly a solution to fsconfigLP(S), e
∗ e ∗ e
which implies fsconfigLP (S) / fsconfigLP (I)/β.

Theorem 7. With high probability, the number of bins used by rna-pack(I, β, ε) is at most
 
γαρ
(ln β)µ + + 2b(dv + 1 + γαµ)ε opt(I) + O(1/ε2 ).
β

Proof. Let JLP be the set of bins packed in the randomized rounding of configuration LP step
(see line 4 in Algorithm 1 in Appendix E), JD be the set of bins used to pack the discarded
items D ∩ S, J be the set of bins used to pack the rest of the items S \ D, and Je be the set of
bins used by complex-pack to pack items in S. e
Then |JLP | ≤ T = ⌈(ln β)kbxk1 ⌉ ≤ (ln β)µ opt(I) + O(1).
Now, we have |JD | ≤ b ⌈2 span(D)⌉ ≤ 2bε span(I) + b ≤ 2b(dv + 1)ε opt(I) + b. The first in-
equality follows from the property of simple-pack, the second follows from C1.1 (Small Discard)
and the last follows from Lemma 2. Finally,
|J| ≤ γ|Je| + O(1) (property of unround (C4))
e + O(1)
≤ γα fsopt(S) (property of complex-pack (C3))
 
e
≤ γα fsopt(I)/β + 2bµε opt(I) + O(1/ε2 ) (by Lemma 6)
≤ γα (ρ/β + 2bµε) opt(I) + O(1/ε2 )
e D) ∈
Here, the last inequality follows from the structural theorem (C2), which says that ∃(I,
round(I) such that fsopt(I)e ≤ ρ opt(I) + O(1). Hence, the total number of bins is at most
 
γαρ
|JLP | + |JD | + |J| ≤ (ln β)µ + + 2b(dv + 1 + γαµ)ε opt(I) + O(1/ε2 ).
β

The AAR of rna-pack(I) is roughly µ ln β + γαρ/β. This is minimized for β = γαρ/µ and
the minimum value is µ (1 + ln (αγρ/µ)). As we require β ≥ 1, we get this AAR only when
γαρ ≥ µ. If µ ≥ γαρ, the optimal β is 1 and the AAR is roughly γαρ.

4.6 Example: simple-pack

We will show how to use simple-pack with the R&A framework. Recall that simple-pack is a
2b(dv + 1)-approximation algorithm for (dg , dv ) BP (see Section 3), where b := 3 when dg = 2,
b := 9 when dg = 3, b := 4dg + 2dg when dg > 3, and b := 1 when dg = 1. Using the R&A
framework on simple-pack will improve its AAR from 2b(dv + 1) to b(1 + ln(2(dv + 1))) + O(ε).
To do this, we need to show how to implement round, complex-pack and unround.
2 e because of which this isn’t completely true. See Lemma 13
There is a caveat in the definition of fsconfigIP∗ (S),
in Appendix E for an explanation and a fix.
3
Rank Lemma: the number of non-zero variables in an extreme-point solution to an LP is at most the number
of constraints. See Lemma 2.1.4 in [33].

12
 1. solve-config-lp(I): Using the KS algorithm of Appendix D and the LP algorithm of
[40], we get a b(1 + ε)-approximate solution to configLP(I). Therefore, µ = b(1 + ε).

2. round(I): returns just one pair: (I,e {}), where Ie := {π(i) : i ∈ I} and π(i) is an item
th
having height (dg geometric dimension) equal to span(i), all other geometric dimensions
equal to 1, and all vector dimensions equal to span(i). There is just one class in Ie and all
items are allowed to be sliced perpendicular to the height, so the homogeneity properties
are satisfied. Also, cmax = dv + 1 by Lemma 2.

3. Structural theorem: We take structured packing to be the set of all possible packings.
e = ⌈span(I)⌉ ≤ (dv + 1) opt(I). Therefore, ρ = dv + 1.
Then fsopt(I)
e We can treat Se as the 1-D bin packing instance {span(i) : i ∈ S} and
4. complex-pack(S):
e ≤ 2 span(S) + 1 ≤ 2 fsopt(S)
pack it using Next-Fit. Therefore, | complex-pack(S)| e + 1.
Therefore, α = 2.

5. unround(Je): For each bin in J, e we can pack the corresponding unrounded items into b
bins (using Steinberg’s algorithm or HDH4 ). Therefore, γ = b.

Therefore, we get an AAR of µ(1 + ln(γαρ/µ)) + O(ε) ≈ b(1 + ln(2(dv + 1))) + O(ε).
For dg = 2, we can slightly improve the AAR by using the (2 + ε)-approximation algorithm
of [32] for (2, dv ) KS. This gives us an AAR of 2(1 + ln(3(dv + 1))) + O(ε). This is better than
the AAR of better-simple-pack for dv ≥ 3.
The above example is presented only to illustrate an easy use of the R&A framework.
It doesn’t exploit the full power of the R&A framework. The algorithm cb-pack, which we
outline in Section 5, uses more sophisticated subroutines round, complex-pack and unround,
and uses a more intricate definition of fractional structured packing to get an even better AAR
of 2(1 + ln( d+4
2 )) + ε (improves to 2(1 + ln(19/12)) + ε ≈ 2.919 + ε for d = 1).

5 Improved Approximation Algorithms

In this section, we give an overview of the cb-pack algorithm for (2, d) BP, which is inspired
from the 1.5 asymptotic approximation algorithm for 2-D GBP [39]. cb-pack is based on the
following two-step procedure, as common in many packing algorithms.
In the first step (structural step), we start with an optimal solution and using some trans-
formation show the existence of a good structured solution. Our structural result roughly says
that if items I can be packed into m bins, then we can round I to get a new instance Ie such
e ≤ ρm + O(1) for some constant ρ, where fsopt(I)
that fsopt(I) e is the number of bins in the
optimal structured fractional packing of I. Roughly, the notion of structured packing that we
use here, which we call compartmental packing, imposes the following additional constraints
over the container-based packing of [39]:

• An item i is said to be dense iff vmax (i)/a(i) is above a certain threshold. If a bin contains
dense items, then we reserve a sufficiently-large rectangular region exclusively for dense
items, and dense items can only be packed into this region.

• For a constant ε, for every j ∈ [d], the sum of the j th weights of items in each bin is at
most 1 − ε.

The proof of our structural result differs significantly from that of [39] because the presence of
vector dimensions inhibit a straightforward application of their techniques.

13
 In the second step (algorithmic step), we show how to find a near-optimal structured solution.
cb-pack first rounds I to Ie and then uses a mixture of brute-force and LP to pack the items
into containers, similar to [39] or [29]. This gives us the optimal structured fractional packing
e Then we convert that packing to a non-fractional packing of I with only a tiny increase
of I.
in the number of bins. Intuitively, rounding is helpful here because it reduces the number of
different types of items by partitioning the items into a constant number of classes such that
items in each class are similar. This simplicity introduced by rounding enables us to find the
optimal structured fractional packing efficiently.
Then we show that cb-pack fits into the R&A framework and gives an AAR of roughly
2(1 + ln(ρ/2)). In particular, Appendix F.9 shows how components from cb-pack can be used
as the R&A subroutines round, complex-pack and unround. To (approximately) solve the con-
figuration LP, we use the linear programming algorithm from [40] and the (2+ ε)-approximation
algorithm for (2, d) KS from [32].
We now give a brief overview of some key ideas used in our structural result. Due to space
limitations, the details of the structural result and the algorithm can be found in Appendix F.
Like [39], we start with a packing of input I into m bins, and transform it into a structured
fractional packing of Ie into ρm + O(1) bins. We do this in three steps:

1. We round up one geometric dimension of each item and pack the items into roughly
ρm + O(1) bins. We call these bins quarter-structured (see Appendices F.2 and F.3).

2. We round the remaining dimensions of items and partition them into classes such that they
satisfy the homogeneity properties (see Section 4.2). We allow slicing and repack the items
into almost the same number of bins. We call the resulting bin packing semi-structured
(see Appendices F.4 and F.5).

3. Finally, we transform the packing into a compartmental packing (see Appendix F.7).
Compartmental packings have nice properties which help us to find them efficiently.

In steps 1, 2 and 3, [39] uses the Next-Fit-Decreasing-Height (NFDH) algorithm [14] to pack
items of O(εm) area into O(εm) bins. This does not work when vector dimensions are present;
an item of low area can have large weights. In step 2, [39] uses linear grouping, i.e., each item is
moved in place of a geometrically larger item so that it can be rounded up. Vector dimensions
make such cross-bin movement difficult, since that can violate bins’ weight capacities. [39] uses
cross-bin movement in step 1 too.
Our first crucial observation is that most difficulties associated with vector dimensions dis-
appear if items’ density is upper-bounded by a constant. Here density of item i is defined as
vmax (i)/a(i). Specifically, if items of bounded density (we call them non-dense items) have small
area, then we can use simple-pack to pack them into a small number of bins. Linear grouping
can also be made to work for such items with some more effort. Therefore, our strategy is to
segregate items as dense and non-dense. We reserve a thin rectangular region in bins for dense
items, and the rest is reserved for non-dense items.
Furthermore, dense items in a bin must have low total area, due to their high density. If
we reserve enough space for them in the bin, we can always pack them in their reserved region
using NFDH (see Lemma 9 in Appendix A). Such a guarantee means that we can essentially
ignore their geometric dimensions and simply treat them as vectors.
In step 2, we want to round up vector dimensions with only a marginal increase in the
number of bins. To do this, we require each quarter-structured bin to be ε-slacked. ε-slackness
roughly means that for a set J of items in a bin, ∀j ∈ [d], vj (J) ≤ 1 − ε (see Appendix F.3 for
a formal description). ε-slackness also helps us in designing the packing algorithm, because we
can then use techniques from resource-augmented vector bin packing. Also, during the rounding

14
 ε

Figure 4: Example of classifying items as blue, red and green based on an ε-strip.

step, we round down the weight of some dense items, and ε-slackness allows us to unround with
no increase in the number of bins.
The observations above guide our definition of quarter-structured. Roughly, a packing is
quarter-structured if items having large width have their width and x-coordinate rounded to a
multiple of ε21 /4 and each bin is ε-slacked. We reserve a thin rectangular region of width ε1 /2
for packing dense items (only if the bin contains dense items).
In step 1, [39] uses a standard cutting-strip argument: They create a strip of width ε1 next
to an edge of the bin (see Fig. 4). Items lying completely inside the strip (called blue items),
have small area and are packed separately using NFDH. Items intersecting the boundary of the
strip (called red items), are removed. This creates an empty space of width ε1 in the bin. Using
this empty space, items lying outside the strip (called green items), can then have their width
and x-coordinate rounded to a multiple of ε21 /2. Their key idea is how to pair up most bins
so that red items from two bins can be rounded and packed together into a new bin. This is
roughly why they get an AAR of 1.5 + ε.
We use the cutting-strip argument too, but with some differences. We cannot freely mix red
items from different bins if they have large weight, and we cannot simply pack blue items into
a small number of bins. We also need bins to be slacked. So, we get a larger AAR of d + 4 + ε.
For d = 1, however, we allow mixing items using more sophisticated techniques, which improves
the AAR to 19/6 + ε. Also, we round green items to a multiple of ε21 /4 instead of ε21 /2, which
leaves an empty strip of width ε1 /2 in the bin even after rounding, and we reserve this space
for dense items. This gives us a quarter-structured packing.
Based on the broad ideas above, we make more changes to the quarter-structured packing
to get a compartmental packing.
Finally, in the algorithmic step, we use a combination of brute-force and LP to pack different
types of items into different type of compartments and find a good compartmental packing
efficiently.
Acknowledgements: We thank Nikhil Bansal and Thomas Rothvoss for their helpful com-
ments.

References
[1] M. T. Alonso, R. Alvarez-Valdes, Manuel Iori, F. Parreño, and J. M. Tamarit.
Mathematical models for multicontainer loading problems. Omega, 66:106–117, 2017.
doi:10.1016/j.omega.2016.02.002.
[2] Samir V. Amiouny, John J. Bartholdi III, John H. Vande Vate, and Jixian Zhang. Balanced
loading. Operations Research, 40(2):238–246, 1992. doi:10.1287/opre.40.2.238.
[3] Nikhil Bansal, Alberto Caprara, and Maxim Sviridenko. A new approximation method for
set covering problems, with applications to multidimensional bin packing. SIAM Journal
on Computing, 39(4):1256–1278, 2009. doi:10.1137/080736831.

15
 [4] Nikhil Bansal, Jose R. Correa, Claire Kenyon, and Maxim Sviridenko. Bin packing in
multiple dimensions: inapproximability results and approximation schemes. Mathematics
of Operations Research, 31:31–49, 2006. doi:10.1287/moor.1050.0168.

[5] Nikhil Bansal, Marek Eliáš, and Arindam Khan. Improved approximation for vector bin
packing. In ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 1561–1579.
SIAM, 2016. doi:10.1137/1.9781611974331.ch106.

[6] Nikhil Bansal and Arindam Khan. Improved approximation algorithm for two-dimensional
bin packing. In SODA, pages 13–25, 2014. doi:10.1137/1.9781611973402.2.

[7] Suman Kalyan Bera, Deeparnab Chakrabarty, Nicolas Flores, and Maryam Negahbani.
Fair algorithms for clustering. In Conference on Neural Information Processing Systems
(NeurIPS), pages 4955–4966, 2019.

[8] Andreas Bortfeldt and Gerhard Wäscher. Constraints in container loading–a state-
of-the-art review. European Journal of Operational Research, 229(1):1–20, 2013.
doi:10.1016/j.ejor.2012.12.006.

[9] Alberto Caprara. Packing 2-dimensional bins in harmony. In FOCS, pages 490–499, 2002.
doi:10.1109/SFCS.2002.1181973.

[10] Alberto Caprara. Packing d-dimensional bins in d stages. Mathematics of Operations

Research, 33:203–215, 2008. doi:10.1287/moor.1070.0289.

[11] Chandra Chekuri and Sanjeev Khanna. On multidimensional packing problems. SIAM
journal on computing, 33(4):837–851, 2004. doi:10.1137/S0097539799356265.

[12] Henrik I. Christensen, Arindam Khan, Sebastian Pokutta, and Prasad Tetali. Approxima-
tion and online algorithms for multidimensional bin packing: A survey. Computer Science
Review, 24:63–79, 2017. doi:10.1016/j.cosrev.2016.12.001.

[13] Edward G. Coffman, János Csirik, Gábor Galambos, Silvano Martello, and Daniele
Vigo. Bin packing approximation algorithms: Survey and classification. In
Handbook of combinatorial optimization, pages 455–531. Springer New York, 2013.
doi:10.1007/978-1-4419-7997-1_35.

[14] Edward G. Coffman, Michael R. Garey, David S. Johnson, and Robert E. Tarjan. Per-
formance bounds for level-oriented two-dimensional packing algorithms. SIAM Journal on
Computing, 9:808–826, 1980. doi:10.1137/0209062.

[15] Florian Diedrich, Rolf Harren, Klaus Jansen, Ralf Thöle, and Henning Thomas. Ap-
proximation algorithms for 3d orthogonal knapsack. Journal of Computer Science and
Technology, 23(5):749, 2008. doi:10.1007/s11390-008-9170-7.

[16] Khaled M. Elbassioni, Naveen Garg, Divya Gupta, Amit Kumar, Vishal Narula, and
Arindam Pal. Approximation algorithms for the unsplittable flow problem on paths and
trees. In FSTTCS, volume 18 of Leibniz International Proceedings in Informatics (LIPIcs),
pages 267–275, 2012. doi:10.4230/LIPIcs.FSTTCS.2012.267.

[17] Wenceslas Fernandez de la Vega and George S. Lueker. Bin packing can be solved within
1 + ε in linear time. Combinatorica, 1:349–355, 1981. doi:10.1007/BF02579456.

[18] A. M. Frieze and M. R. B. Clarke. Approximation algorithms for the m-dimensional 0 − 1

knapsack problem: worst-case and probabilistic analyses. EJOR, 15:100–109, 1984.

16
[19] Waldo Gálvez, Fabrizio Grandoni, Afrouz Jabal Ameli, Klaus Jansen, Arindam Khan,
and Malin Rau. A tight (3/2+ ε) approximation for skewed strip packing. In Approx-
imation, Randomization, and Combinatorial Optimization. Algorithms and Techniques
(APPROX/RANDOM 2020). Schloss Dagstuhl-Leibniz-Zentrum für Informatik, 2020.
doi:10.4230/LIPIcs.APPROX/RANDOM.2020.44.

[20] Waldo Gálvez, Fabrizio Grandoni, Sandy Heydrich, Salvatore Ingala, Arindam Khan, and
Andreas Wiese. Approximating geometric knapsack via l-packings. In 2017 IEEE 58th An-
nual Symposium on Foundations of Computer Science (FOCS), pages 260–271. IEEE, 2017.
Full version available at http://www.dii.uchile.cl/~awiese/2DK_full_version.pdf.
doi:10.1109/FOCS.2017.32.

[21] Waldo Gálvez, Fabrizio Grandoni, Salvatore Ingala, and Arindam Khan. Improved pseudo-
polynomial-time approximation for strip packing. In FSTTCS, pages 9:1–9:14, 2016.
doi:10.4230/LIPIcs.FSTTCS.2016.9.

[22] Paul C Gilmore and Ralph E Gomory. Multistage cutting stock problems of two and more
dimensions. Operations research, 13(1):94–120, 1965. doi:10.1287/opre.13.1.94.

[23] Rebecca Hoberg and Thomas Rothvoss. A logarithmic additive integrality gap for bin
packing. In SODA, pages 2616–2625, 2017. doi:10.1137/1.9781611974782.172.

[24] Klaus Jansen and Lars Prädel. New approximability results for two-dimensional bin pack-
ing. Algorithmica, 74(1):208–269, 2016. doi:10.1007/s00453-014-9943-z.

[25] Klaus Jansen and Guochuan Zhang. Maximizing the number of packed rectangles. In
SWAT, pages 362–371, 2004. doi:10.1007/978-3-540-27810-8_31.

[26] D. S. Johnson. Approximation algorithms for combinatorial problems. In STOC, pages

38–49, 1973.

[27] Matthew Joseph, Michael J. Kearns, Jamie H. Morgenstern, and Aaron Roth. Fairness in
learning: Classic and contextual bandits. In NeurIPS, pages 325–333, 2016.

[28] Hans Kellerer, Ulrich Pferschy, and David Pisinger. Knapsack problems. Springer, 2004.

[29] Claire Kenyon and Eric Rémila. Approximate strip packing. In 37th Annual Symposium on
Foundations of Computer Science, FOCS ’96, Burlington, Vermont, USA, 14-16 October,
1996, pages 31–36, 1996. doi:10.1109/SFCS.1996.548461.

[30] Arindam Khan. Approximation algorithms for multidimensional bin packing. PhD thesis,
Georgia Institute of Technology, Atlanta, GA, USA, 2016.

[31] Arindam Khan and Madhusudhan Reddy Pittu. On guillotine separability of squares
and rectangles. In Approximation, Randomization, and Combinatorial Optimization. Al-
gorithms and Techniques (APPROX/RANDOM 2020). Schloss Dagstuhl-Leibniz-Zentrum
für Informatik, 2020. doi:10.4230/LIPIcs.APPROX/RANDOM.2020.47.

[32] Arindam Khan, Eklavya Sharma, and K. V. N. Sreenivas. Approximation algorithms for
generalized multidimensional knapsack, 2021. arXiv:2102.05854.

[33] Lap Chi Lau, Ramamoorthi Ravi, and Mohit Singh. Iterative methods in combinatorial
optimization, volume 46. Cambridge University Press, 2011.

[34] Eugene L Lawler. Fast approximation algorithms for knapsack problems. Mathematics of
Operations Research, 4(4):339–356, 1979. doi:10.1287/moor.4.4.339.

17
[35] Colin McDiarmid. On the method of bounded differences. Surveys in combinatorics,
141(1):148–188, 1989.

[36] Maria Flavia Monaco, Marcello Sammarra, and Gregorio Sorrentino. The
terminal-oriented ship stowage planning problem. EJOR, 239(1):256–265, 2014.
doi:10.1016/j.ejor.2014.05.030.

[37] Célia Paquay, Michael Schyns, and Sabine Limbourg. A mixed integer programming
formulation for the three-dimensional bin packing problem deriving from an air cargo
application. International Transactions in Operational Research, 23(1-2):187–213, 2016.
doi:10.1111/itor.12111.

[38] Deval Patel, Arindam Khan, and Anand Louis. Group fairness for knapsack problems.
ArXiv, 2006.07832, 2020. arXiv:2006.07832.

[39] Lars Dennis Prädel. Approximation Algorithms for Geometric

Packing Problems. PhD thesis, Kiel University, 2012. URL:
https://macau.uni-kiel.de/servlets/MCRFileNodeServlet/dissertation_derivate_00004634/dis

[40] Eklavya Sharma. An approximation algorithm for covering linear programs and its appli-
cation to bin-packing, 2020. arXiv:2011.11268.

[41] Knut Olav Brathaug Sørset. A heuristic approach to the three-dimensional bin packing
problem with weight constraints. Master’s thesis, Høgskolen i Molde-Vitenskapelig høgskole
i logistikk, 2019.

[42] A. Steinberg. A strip-packing algorithm with absolute performance bound 2. SIAM Journal
on Computing, 26(2):401–409, 1997. doi:10.1137/S0097539793255801.

[43] Gregory S. Taylor, Yupo Chan, and Ghulam Rasool. A three-dimensional bin-packing
model: exact multicriteria solution and computational complexity. Annals of Operations
Research, 251(1-2):397–427, 2017. doi:10.1007/s10479-015-2048-5.

[44] Alan Tsang, Bryan Wilder, Eric Rice, Milind Tambe, and Yair Zick. Group-fairness in
influence maximization. In IJCAI, pages 5997–6005, 2019.

[45] Gerhard J. Woeginger. There is no asymptotic PTAS for two-dimensional vector packing.
Inf. Process. Lett., 64(6):293–297, 1997. doi:10.1016/S0020-0190(97)00179-8.

[46] Guang Yang. gbp: a bin packing problem solver, 2017. R package version 0.1.0.4. URL:
https://CRAN.R-project.org/package=gbp.

A Some Simple Packing Algorithms

Claim 8 (Next-Fit). Let I := {i1 , i2 , . . . , in } bela 1D bin m
packing problem instance. The Next-
Pn
Fit algorithm finds a packing of I into at most 2 j=1 ij bins.

Lemma 9 (NFDH for strip packing [14]). A set I of rectangles can be packed into a strip of
height at most 2a(I) + maxi∈I h(i) using the Next-Fit Decreasing Height (NFDH) algorithm.

Lemma 10 (NFDH for small items [14]). Let I be a set of rectangles where each rectangle has
width at most δW and height at most δH . Let there be a rectangular bin of width W and height
H. If a(I) ≤ (W − δW )(H − δH ), then NFDH can pack I into the bin.

18
B Omitted Proofs
Lemma 11 (Steinberg’s algorithm [42]). Let I be a set of rectangles. Let wmax := maxi∈I w(i)
and hmax := maxi∈I h(i). Consider a bin of width W and height H, where wmax ≤ W and
hmax ≤ H. Then there is a O(n log2 n/ log log n)-time algorithm to pack I into the bin if


2a(I) ≤ W H − max(2wmax − W, 0)) · (max(2hmax − H, 0)

Proof of Lemma 3. Pack I into a bin of width 2 and height 1 using Steinberg’s algorithm (see
Lemma 11). Then cut the bin vertically into 2 unit-sized squares. The items which lie completely
inside the left half can be packed into a unit-sized bin. The items which lie completely inside
the right half can be packed into a unit-sized bin. The items which lie on the cutting line are
stacked one-over-the-other, so we can pack them into a unit-sized bin.

C The HDH4 Algorithm

Lemma 12. Let I be a set of dg -dimensional cuboids. Then I can be packed into at most
4dg + 2dg vol(I) bins using a variant of HDH4 .

Proof. Define f4 : [0, 1] 7→ [0, 1] and type4 : [0, 1] 7→ [4] as

(  i (  i
1 1 1 1 1
x ∈ , for q ∈ [3] q x ∈ , for q ∈ [3]
f4 (x) = q q+1 q
type4 (x) = q+1 q
1 1
2x x ≤ 4 4 x≤ 4

Note that x ≤ f4 (x) ≤ 2x. Let i be a dg -dimensional cuboid. Define f4 (i) as the cuboid of
length f4 (ℓj (i)) in the j th dimension. Therefore, vol(i) ≤ vol(f4 (i)) ≤ 2dg vol(i). For a set I of
cuboids, f4 (I) := {f4 (i) : i ∈ I}. Define type(i) to be a d-length vector whose j th component is
type(ℓj (i)).
For a set I of cuboids, define I (k) to be the set of items obtained by ignoring all dimensions
[t]
other than the first k. [10] (implicitly) defines a recursive algorithm HDH-unit-pack4 (I, d). For
a sequence I of dD cuboids all having the same type4 t, where vol(f4 ((I − {last(I)})(d) )) < 1,
[t]
HDH-unit-pack4 (I, d) returns a packing of I (d) into a dD bin. Here last(I) is the last item in
sequence I.
Now I’ll define a slight variation of the HDH4 algorithm in [10]. This variant also works
when rotation of items is allowed. First, partition the items by type4 . The number of partitions
is at most Q = 4dg . Let I [q] be the partition containing items of type4 q. Order the items in
I [q] arbitrarily. Then repeatedly pick the smallest prefix J of I [q] such that either J = I [q] or
[q]
vol(f4 (J)) ≥ 1, and pack J into a bin using HDH-unit-pack4 (J, dg ).
[q]
Suppose HDH4 (I [q] ) produces m[q] bins. Let Bj be the j th of these bins. Given the way we
[q]
choose prefixes, vol(f4 (Bj )) ≥ 1 for j ∈ [m[q] − 1], i.e. at most 1 bin is partially-filled.

m[q]
X [q]
[q]
vol(f4 (I )) = vol(f4 (Bj )) ≥ (m[q] − 1)
j=1

Total number of bins used is

Q
X Q
X
[q]
m ≤ (1 + vol(f4 (I [q] ))) ≤ Q + vol(f4 (I)) = 4dg + 2dg vol(I)
q=1 q=1

19
D Algorithm for Knapsack
Let I be a set of (2, d)-dimensional items. Let p(i) be the profit of item i. We want to pack
a max-profit subset of I into a bin. Let Ib be a set of (d + 1)-dimensional vectors obtained
by replacing the geometric dimensions of each item i by a single vector dimension a(i). Let
A be a (d + 1)-D VKS algorithm having approximation ratio α ≥ 1. A gives us a packing
of items Jb ⊆ Ib into a bin. Let J be the corresponding items in I. Then vol(J) ≤ 1 and
∀k ∈ [d], vk (J) ≤ 1. Use Steinberg’s algorithm to compute a packing of J into 3 bins: J1 , J2 , J3 .
W.l.o.g., assume p(J1 ) ≥ p(J2 ) ≥ p(J3 ). Then output the packing J1 as the answer to the (2,
d) KS problem. Since any feasible solution to the (2, d) KS instance (I, p) also gives a feasible
solution to the VKS instance (I,b p), we get opt(I,
b p) ≥ opt(I, p). Since A is α-approximate, we
get p(J) ≥ opt(I,b p)/α. Hence,

p(J) b p)
opt(I, opt(I, p)
p(J1 ) ≥ ≥ ≥
3 3α 3α
Therefore, we get a 3α-approximation algorithm for (2, d) KS. Using the PTAS for (d + 1)-D
VKS by Frieze and Clarke [18], we get α = 1 + ε.

E Details of the R&A Framework

e ≤ fsconfigIP∗ (S)
Lemma 13. fsopt(S) e ≤ fsopt(S)
e + q.

Proof. Due to the downward closure property, changing inequality constraints to equality con-
straints doesn’t affect the optimum values of the above LP and IP. Therefore, fsconfigIP(S) e is
equivalent to the fractional structured bin packing problem.
A problem with the above definition of fsconfigLP(I) e is that the number of variables can be
infinite if certain classes allow slicing. We circumvent this problemby discretizing the configu- 
dg
rations: Let δ be the smallest dimension of any item, i.e. δ := min minj=1 ℓj (i), mindj=1
v
vj (i) .
In any optimal integral solution to fsconfigLP(I) e that uses m bins, we can slice out some
items from each class in each bin so that the span of each class in each bin is a multiple of
δdg /n. In each class, the total size of sliced out items across all bins is at most δdg . Therefore,
for each class, slices of that class can fit into a single item of that class. If each such single item
is packed in a separate bin, the total number of bins used is at most m + q.
Therefore, we only need to consider configurations where either the span of each class is a
multiple of δdg /n or there is a single item in the configuration. This gives us a finite number of
configurations and completes the proof.
e ≤ fsconfigIP∗ (S)
Lemma 14. fsconfigLP∗ (S) e ≤ fsconfigLP∗ (S)
e + q.

Proof. By rank lemma, the number of positive-valued variables in an extreme-point solution to

a linear program is at most the number of constraints (other than the variable non-negativity
constraints).
Thus, an optimal extreme-point solution to fsconfigLP(S) e has at most q positive-valued
variables. Rounding up those variables to the nearest integer will give us an integral solution
e ≤ fsconfigLP∗ (S)
and increase the objective value by at most q. Hence, fsconfigIP∗ (S) e + q.

Let configLP(I) denote the configuration LP of items I and let configLP∗ (I) denote the
optimal objective value of configLP(I). Recall that simple-pack is a 2b(dv + 1)-approximation
algorithm for (dg , dv ) BP (see Section 3), where b := 3 when dg = 2, b := 9 when dg = 3,
b := 4dg + 2dg when dg > 3, and b := 1 when dg = 1.

20
Lemma 15. For a set I of (dg , dv )-dimensional items, configLP∗ (I) ∈ Θ(span(I)) + O(1).

Let x∗ be the optimal solution to configLP(I). In

Proof. Let A be the configuration matrix of I. P
configLP(I), the constraint for item i gives us C∈C A[i, C]x∗C ≥ 1. Multiplying each constraint
by span(i) and adding these constraints together, we get
XX X
span(I) ≤ span(i)A[i, C]x∗C = span(C)x∗C
C∈C i∈I C∈C
X
≤ (dv + 1) x∗C = (dv + 1) configLP∗ (I).
C∈C

Therefore, configLP∗ (I) ≥ span(I)/(dv + 1). We also have

configLP∗ (I) ≤ opt(I) ≤ | simple-pack(I)| ≤ 2b span(I) + b.

Therefore, configLP∗ (I) ∈ Θ(span(I)) + O(1).

Lemma 16 (Independent Bounded Difference

Q Inequality [35]). Let X := [X1 , X2 , . . . , Xn ] be
random variables with Xj ∈ Aj . Let φ : ni=1 Aj 7→ R be a function such that |φ(x) − φ(y)| ≤ cj
whenever vectors x and y differ only in the j th coordinate. Then for any t ≥ 0,
!
2t2
Pr[φ(X) − E(φ(X)) ≥ t] ≤ exp − Pn 2 .
j=1 cj

Lemma 17. Let Se be as computed by rna-pack(I, β, ε). Let ε ∈ (0, 1) be a constant. When
span(I) is large compared to 1/ε2 , we get that with high probability
∗ e
e ≤ fsconfigLP (I) + 2bµε opt(I) + O(1).
fsconfigLP∗ (S)
β

Proof. Let y ∈ C T be the configurations chosen during randomized rounding. When viewed S as
a vector of length T , all coordinates of y are independent. Define uncovered(y) := I − Tt=1 yt .
e1, K
Let K e2, . . . , K
e q be the classes of I.
e Let π be the bijection from I − D to I.
e For a set
e T
X ⊆ I, define I[X] := {π(i) : i ∈ X − D}. For j ∈ [q], define φj ∈ C 7→ R≥0 as
 
φj (y) := span Ke j ∩ I[uncovered(y)]
e .

e j ∩ I[X]).
For any set X ⊆ I, define gj (X) := span(K e Then φj (y) = gj (uncovered(y)) and gj is
a non-negative additive function.
(1)
Let y (1) , y (2) ∈ C T such that y (1) and y (2) differ only in coordinate t. Let yt = C1 and
(2)
yt = C2 . Let S1 = uncovered(y (1) ) and S2 = uncovered(y (2) ).
It is easy to see (using Venn diagrams) that S1 − S2 ⊆ C2 − C1 and S2 − S1 ⊆ C1 − C2 .

φj (y (1) ) − φj (y (2) ) = |gj (S1 ) − gj (S2 )|

= |gj (S1 − S2 ) − gj (S2 − S1 )| (additivity of gj )
≤ max(gj (S1 − S2 ), gj (S2 − S1 ))
≤ max(gj (C2 ), gj (C1 ))
≤ max span(K e j ∩ I[C])
e ≤ cmax . (by bounded expansion lemma)
C∈C

21
 E(φj (y)) = E(gj (S))
X
= gj ({i}) Pr(i ∈ S) (linearity of expectation and additivity of gj )
i∈Ie
X
≤ gj ({i})(1/β) (by Lemma 5)
i∈Ie
e
gj (I) ej )
span(K
= = .
β β

∀j ∈ [q], define Qj as the e e e e

Sqsmallest prefix of S ∩ Kj such that either Qj = S ∩ Kj or span(Qj ) ≥
xk1 /q. Define Q := j=1 Qj . Therefore,
ε kb

span(Q) ≤ ε kb
xk1 + q ≤ εµ opt(I) + O(1).

e ≤ fsconfigLP∗ (Se − Q) + fsconfigLP∗ (Q)

fsconfigLP∗ (S)
≤ fsconfigLP∗ (Se − Q) + b(2 span(Q) + 1) (by Section 3)
≤ fsconfigLP (Se − Q) + 2bµε opt(I) + O(1).
∗

Now we will try to prove that with high probability, fsconfigLP∗ (Se − Q) ≤ fsconfigLP∗ (I)/β.e
If Qj = Se ∩ K
e j , then span(K e j ∩ (Se − Q)) = 0. Otherwise,
" # " #
span( ej )
K span( ej )
K
Pr span(K e j ∩ (Se − Q)) ≥ = Pr span(Ke j ∩ S)
e − ≥ span(Qj )
β β
   2 !
ε 2 ε
≤ Pr φj (y) − E(φj (y)) ≥ kb xk1 ≤ exp − 2 kb
xk 1 (Lemma 16)
q T cmax q
 
2ε2
≤ exp − kb
xk 1 .
ln(β)c2max q 2

Therefore, by union bound, we get

 !
_q e  
 e e span(Kj )  2ε2
Pr span(Kj ∩ (S − Q)) ≥ ≤ q exp − kb
xk 1 .
β ln(β)c2max q 2
j=1

Since configLP∗ (I) ≤ kb

xk1 ≤ µ configLP∗ (I) + O(1), and configLP∗ (I) ∈ Θ(span(I)) + O(1) (by
Lemma 15), we get kb xk1 ∈ Θ(span(I)) + O(1). When span(I) is very large compared to 1/ε2 ,
we get that with high probability, ∀j ∈ [q],

e
e j ∩ (Se − Q)) ≤ span(Kj ) .
span(K
β

e Then with high probability, x∗ /β is a feasible

Let x∗ be the optimal solution to fsconfigLP(I).
solution to fsconfigLP(Se − Q). Therefore,
e ≤ fsconfigLP∗ (Se − Q) + 2bµε opt(I) + O(1)
fsconfigLP∗ (S)
e
≤ fsconfigLP∗ (I)/β + 2bµε opt(I) + O(1).

Lemma 6. Let Se be as computed by rna-pack(I, β, ε). Then with high probability, we get
e ≤ fsopt(I)/β
fsopt(S) e + 2bµε opt(I) + O(1/ε2 ).

22
Proof. When span(I) is very large compared to 1/ε2 , we get
e ≤ fsconfigIP∗ (S)
fsopt(S) e + O(1) (by Lemma 13)
e + O(1)
≤ fsconfigLP∗ (S) (by Lemma 14)
∗e
≤ fsconfigLP (I)/β + 2bµε opt(I) + O(1) (by Lemma 17)
e
≤ fsopt(I)/β + 2bµε opt(I) + O(1). (by Lemma 13)

Otherwise, if span(I) ∈ O(1/ε2 ), we get

e ≤ ρ opt(I) + O(1)
fsopt(S) (by structural theorem)
≤ ρ| simple-pack(I)| + O(1)
≤ Θ(span(I)) + O(1) ≤ O(1/ε2 ). (by Section 3)

E.1 Error in Previous R&A Framework

Here we describe a minor error in the R&A framework of [30], and how it can be fixed.
e D) as an output of round(I) and for the residual instance S, we define Se as
We define (I,
the corresponding rounded items of S − D. Our proof of Lemma 6 relies on the fact that for any
subset of rounded items, the span reduces by a factor of at least β if we restrict our attention
e ⊆ I,
to the residual instance. Formally, this means that for any X e we have
X
E(span(Xe ∩ S))
e = e ≤ span(X)/β.
span(i) Pr(i ∈ S) e
e
i∈X

The equality follows from linearity of expectation and the fact that span(i) is deterministic,
i.e., it doesn’t depend on the randomness used in the randomized rounding of the configuration
LP. This is because round is not given any information about what S is. The inequality follows
from Lemma 5, which says that Pr(i ∈ S) ≤ 1/β.
The R&A framework of [30] used similar techniques in their analysis. In their algorithm,
however, they round items differently. Specifically, they define a subroutine round and define
Ie := round(I) and Se := round(S). They, too, claim that for any subset of rounded items, the
span reduces by a factor of at least β if we restrict our attention to the residual instance. While
their claim is correct for input-agnostic rounding (where items are rounded up to some constant
size collection values chosen independent of the problem instance), the claim is incorrect for
input-sensitive rounding (where the values are chosen based on the specific problem instance).
So the claim is incorrect if round is not deterministic, as then an item can be rounded differently
depending on different residual instances.
In fact, they use their R&A framework with the algorithm of Jansen and Prädel [24], which
uses linear grouping (along with some other techniques) for rounding. Linear grouping rounds
items in an input-sensitive way, i.e., the rounding of each item depends on the sizes of items in
S which is a random subset.

F Algorithm for (2, d) Bin Packing

Here we will see a rounding-based algorithm for (2, d) bin packing, called cb-pack (named after
‘compartment-based packing’). cb-pack will be parametrized by a parameter ε, where ε−1 ∈ 2Z
and ε ≤ 1/8.
Claim 18. If a set J of items fits into a bin, then vmax (J) ≤ d and span(J) ≤ d + 1.

23
 We will first remove some items from the bin, so that the remaining items can be classified
into useful categories.

F.1 Classifying Items

Definition 5. For constants ε2 < ε1 , a bin packing instance I is called (ε2 , ε1 )-non-medium iff
∀i ∈ I, (w(i) 6∈ (ε2 , ε1 ]) ∧ (h(i) 6∈ (ε2 , ε1 ]) ∧ (∀j ∈ [d], vj (i) 6∈ (ε2 , ε1 ]).

An (ε2 , ε1 )-non-medium instance has useful properties. Therefore, we want to remove some
items from the input instance I so that it becomes (ε2 , ε1 )-non-medium and the removed items
can be packed into a small number of bins.

Definition 6. Let δ0 , ε ∈ (0, 1] be constants and let f : (0, 1] 7→ (0, 1] be a function such that
∀x ∈ (0, 1], f (x) < x. Let T := ⌈(d + 2)/ε⌉. For t ∈ [T ], define δt := f (δt−1 ) and define
  
 d
_ 
Jt := i ∈ I : w(i) ∈ (δt , δt−1 ] ∨ h(i) ∈ (δt , δt−1 ] ∨  vj (i) ∈ (δt , δt−1 ] .
 
j=1

Define remove-medium(I, ε, f, δ0 ) as the tuple (Jr , δr , δr−1 ), where r := argminTt=1 span(Jt ).

Lemma 19. Let (Imed , ε2 , ε1 ) := remove-medium(I, ε, f, δ0 ). Then span(Imed ) ≤ ε span(I).

Proof. Each item belongs to at most d + 2 sets Jt . Therefore,

T
T 1X d+2
span(Imed ) = min span(Jt ) ≤ span(Jt ) ≤ span(I) ≤ ε span(I).
t=1 T ⌈(d + 2)/ε⌉
t=1

By Definition 6, I − Imed is (ε2 , ε1 )-non-medium. By Lemma 19 and Theorem 4, span(Imed )

can be packed into at most 6(d + 1)ε opt(I) + 3 bins using the simple-pack algorithm.
We will choose f to be independent of I, so ε1 and ε2 are constants. Also note that
ε2 := f (ε1 ) and ε1 ≤ δ0 . We choose δ0 := min (1/(4d + 1), 2ε/3), so δ0−1 ∈ Z. We will choose f
later. For now, we will impose these conditions: f (x) ≤ εx2 /2, and (x−1 ∈ Z =⇒ f (x)−1 ∈ Z).
The second condition implies that ε−1 −1
1 , ε2 ∈ Z.
Henceforth, assume all (2, d) bin packing instances to be (ε2 , ε1 )-non-medium.

Definition 7. We can classify item i by its geometric dimensions as follows:

• Big item: w(i) > ε1 and h(i) > ε1 .

• Wide item: w(i) > ε1 and h(i) ≤ ε2 .
• Tall item: w(i) ≤ ε2 and h(i) > ε1 .
• Small item: w(i) ≤ ε2 and h(i) ≤ ε2 .

When rotation of items is allowed, assume w.l.o.g. that there are no tall items in I.

Definition 8 (Dense items). Item i is dense iff either a(i) = 0 or vmax (i)/a(i) > 1/ε21 .

Note that big items cannot be dense.

Definition 9 (Heavy and light items). A dense item i is said to be heavy in vector dimension
j iff vj (i) ≥ ε1 . Otherwise i is said to be light in dimension j. If i is heavy in some dimension,
then i is said to be heavy, otherwise i is light.

24
F.2 Rounding One Side
In this subsection, we will show how a packing of I into bins can be modified to get a more
structured packing where one of the geometric dimensions is rounded up.
Definition 10. In a bin, assume a coordinate system where (0, 0) is at the bottom left and (1, 1)
is on the top right. We define the following regions, called strips:
′
• S (T ) := [0, 1] × [1 − ε1 , 1] and S (T ) := [0, 1] × [1 − ε1 /2, 1].
• S (B) := [0, 1] × [0, ε1 ].
• S (L) := [0, ε1 ] × [0, 1].
′
• S (R) := [1 − ε1 , 1] × [0, 1] and S (R ) := [1 − ε1 /2, 1] × [0, 1].

We say that an item intersects a strip iff a non-zero volume of that item lies inside the strip.
Property 11. A bin is said to satisfy Property 11 iff both of these conditions hold:

a The x-coordinate and width of all non-dense wide and big items is a multiple of ε21 /4.
′
b If the bin contains dense items, then dense items are packed inside S (R ) and no non-dense
′
item intersects S (R ) .
Property 12. A bin is said to satisfy Property 12 iff both of these conditions hold:

a The y-coordinate and height of all non-dense tall and big items is a multiple of ε21 /4.
′)
b If the bin contains dense items, then dense items are packed inside S (T and no non-dense
′
item intersects S (T ) .

Equivalently, we can say that a bin satisfies Property 12 iff its mirror image about the line
y = x satisfies Property 11.
The main result of this subsection is the following:
Lemma 20. Given a packing of items into a bin, we can round up the width of some wide and
big non-dense items to a multiple of ε21 /4 or round up the height of some tall and big non-dense
items to a multiple of ε21 /4 and get a packing into 2 bins and 2 boxes where:

• Each bin satisfies either Property 11 or Property 12.

• v1 of each box is at most 1/2.
• One of the boxes has only dense items. Its larger dimension is 1 and its smaller dimension
is δd := 2dε21 + ε2 .
• One of the boxes has only non-dense items. Its larger dimension is 1 and its smaller
dimension is ε1 + ε2 .
• One of the boxes is horizontal, i.e., has width 1 and only contains wide and small items.
The other box is vertical, i.e., has height 1 and only contains tall and small items.

Before proving Lemma 20, we first prove a few ancillary results.

For X ∈ {T, B}, the items lying completely inside S (X) are either small or wide. Let C (X) be
the set of small and wide items that intersect S (X) . For X ∈ {L, R}, the items lying completely
inside S (X) are either small or tall. Let C (X) be the set of small and tall items that intersect
S (X) . Since 2ε1 + ε2 ≤ 1, we get C (T ) ∩ C (B) = C (L) ∩ C (R) = {}.
W.l.o.g., assume that v1 (C (T ) ) ≤ 1/2 because v1 (C (B) ∪ C (T ) ) ≤ 1 and if v1 (C (T ) ) >
v1 (C (B) ), then we can mirror-invert the bin along a horizontal axis. Similarly assume that
v1 (C (R) ) ≤ 1/2.

25
Observation 21. If a bin only contains tall and small items, it trivially satisfies Property 11a.
If a bin only contains wide and small items, it trivially satisfies Property 12a.
Lemma 22. Suppose we’re given a packing of items into a bin such that no item intersects
S (R) . Then we can increase the widths of all wide and big items to a multiple of ε21 /4 and
′
repack the items so that they satisfy Property 11a and no item intersects S (R ) .

Proof. Let yb (i) and yt (i) be the y-coordinates of the bottom and top edge respectively of item
i. If an item j intersects the strip [0, 1] × [yb (i), yt (i)] and lies to the right of i (i.e. the left
edge of j is to the right of the right edge of i), we say that i ≺imm j (see Fig. 5). Let  denote
the reflexive and transitive closure of the relation ≺imm . It is easy to see that  is a partial
ordering of I. Define i ≺ j as i  j ∧ i 6= j.

B
D
A

Figure 5: Items A, B, C and D in a bin. Here A ≺imm D but A 6≺imm C. Also,

A ≺imm B ≺imm C, so A  C.

Define pw (i) to be 1 if it is wide or big and to be 0 if it is neither wide nor big. Also, define
nw (i) := pw (i) + maxj≺i nw (j) (if there is no j ≺ i, define maxj≺i nw (i) := 0). Intuitively, nw (i)
denotes the length of the largest chain of wide items preceding i. The x-coordinate of the right
edge of item i is more than ε1 nw (i). Therefore, nw (i) < 1/ε1 − 1.
Transformation 13. Move each item i to the right by (nw (i) − pw (i))ε21 /2. Additionally, if i
is wide or big, move it further to the right so that the x-coordinate of its left edge is a multiple
of ε21 /4, and increase its width so that it is a multiple of ε21 /4.

On applying Transformation 13 to item i, the x-coordinate of its right edge increases by less
than nw (i)ε21 /2. Since nw (i) < 1/ε1 − 1, the increase is less than ε1 /2. Therefore, i will not
′
intersect S (R ) after this transformation. Also, after applying this transformation to all items,
the bin satisfies Property 11a.
We will now prove that after applying Transformation 13 to all items, no items overlap.
If i and j are not relatively ordered by , they cannot overlap because we only moved items
rightwards. Now assume w.l.o.g. that i ≺ j. The x-coordinate of the right edge of i increases
by less than nw (i)ε21 /2. The x-coordinate of the left edge of j increases by at least (nw (j) −
pw (j))ε21 /2. Since nw (i) ≤ maxi′ ≺j nw (i′ ) = nw (j) − pw (j), i and j don’t overlap.

Lemma 23. Let R be a set of wide and small items that are dense and have total weight at
most 1. They can be packed in polynomial time into a box of width 1 and height δd := 2dε21 + ε2 .

Proof. a(R) ≤ ε21 vmax (R) ≤ dε21 .

So by Lemma 9, height used by NFDH is less than 2a(R) + ε2 ≤ 2dε21 + ε2 .

We can get an analogous result for tall and small dense items.

Proof of Lemma 20. Suppose the bin contains items J. Then we can use Lemma 23 to move
dense wide items to box DW and move dense tall and small items to box DH . We will later
repack one of DW and DH into a bin.

26
 v1 (DW ∪ DH ) ≤ 1. This gives us 2 cases: v1 (DW ) ≤ 1/2 or v1 (DH ) ≤ 1/2. The first
case is the same as the second one with the coordinate axes swapped, so assume w.l.o.g. that
v1 (DW ) ≤ 1/2.
Move C (R) to a box of height 1 and width ε1 + ε2 ≤ 1/2. C (R) only has tall and small
non-dense items. Also, v1 (C (R) ) ≤ 1/2.
Let I (R) be the set of big and wide items that intersect S (R) . Move I (R) to a separate bin.
The items in I (R) are stacked on top of each other. Therefore, we can round their widths to a
multiple of ε21 /4. I (R) doesn’t have dense items. Therefore, this new bin satisfies the desired
properties.
Since we removed C (R) and I (R) from the bin, S (R) is empty. By Lemma 22, we can round
the x-coordinate and width of big and wide items in the bin to a multiple of ε21 /4 and then
′
repack the items in the bin so that the bin satisfies Property 11a and S (R ) is empty. Observe
that
εε21 ε1 ε1
δd = 2dε21 + ε2 ≤ 2dε21 + ≤ (4d + 1)ε1 ≤ .
2 2 2
′
Since δd ≤ ε1 /2, pack DH into S (R ) . Now this bin also satisfies Property 11b. In total, we
used 2 bins and 2 boxes (C (R) and DW ). The dense box is horizontal and the non-dense box is
vertical. Refer to Fig. 6 for an example.

ε1 ε1 + ε2

Figure 6: A bin is split into 2 bins and 2 boxes. Then the widths and x-coordinates of big and
wide non-dense items are rounded up to a multiple of ε21 /4. Dense items are shaded dark and
non-dense items are shaded light.

27
Lemma 24. When item rotation is allowed, given a packing of items into a bin, we can round
up the width of some wide and big items to a multiple of ε21 /4 and round up the height of some
tall and big items to a multiple of ε21 /4 and get a packing into 2 bins and 1 box where:

• Each bin satisfies Property 11.

• v1 of the box is at most 1/2.
• The box has height 1 and width ε1 + ε2 .
• The box only contains tall and small non-dense items.

Proof sketch. Suppose the bin contains items J. Move dense items to a vertical box DH using
Lemma 23. Move C (R) to a box of height 1 and width ε1 + ε2 . Move I (R) to a new bin and
′ ′
round item widths to a multiple of ε21 /4. Now S (R ) is empty, so pack DH into S (R ) . The rest
of the proof is similar to that of Lemma 20.

F.3 Getting Slack in Weight of Bins

For a bin J, if ∀j ∈ [d], vj (J) ≤ 1 − ε, then we can round up weights of items. Hence, we would
like to have bins with (roughly) this property.

Definition 14. A bin J is said to be ε-slacked iff at least one of these conditions holds:

• ∀j ∈ [d], vj (J) ≤ 1 − ε.

• |J| = 1.

• |J| = 2 and J only contains dense items and ∀i ∈ J, vmax (i) ≤ 1/2.

A packing of items into multiple bins is said to be ε-slacked iff all bins in the packing are
ε-slacked.

We say that packing of items in a bin is quarter-structured iff the bin is ε-slacked and satisfies
either Property 11 or Property 12. We would like to round up the width or height of each item
in I and repack the items into bins such that each bin is quarter-structured.

Lemma 25. Let D ⊆ [d] and we have a parameter δ ≤ 1/4. Let I be a set of items where
∀j ∈ D, vj (I) ≤ Vj . Then we can partition I into at most |D| + 1 disjoint subsets such that each
subset I ′ satisfies one of these properties:

• |I ′ | = 1.

• ∀j ∈ D, vj (I ′ ) ≤ (1 − δ)Vj .

Proof. Let IL := {i ∈ I : ∃j ∈ D, vj (i) > (1 − 2δ)Vj }. Move each item in IL to a new box. Let
D ′ := {j ∈ D : vj (IL ) > (1−2δ)Vj }. Then |D ′ | ≥ |IL | and ∀j ∈ D ′ , vj (I −IL ) < 2δVj ≤ (1−δ)Vj .
Order the items in I − IL arbitrarily. For each j ∈ D − D ′ , find the smallest prefix Pj such
that vj (Pj ) ≥ δVj . Let ij be the last item in Pj . Then vj (Pj − ij ) < δVj . Since we removed
items from IL , vj (ij ) ≤ (1 − 2δ)Vj . Therefore, vj (Pj ) ≤ (1 − δ)Vj .
Now order these prefixes in non-decreasing order of cardinality. Let them be P1′ , P2′ , . . .,
′
P|D−D ′ ′ ′ ′ ′
′ | . The sets P1 , P2 −P1 , P3 −P2 , . . . form a partition of P|D−D ′ | . Put each such set in a new

box, if the set is not empty. The items which remain in the original box are Q := I −IL −P|D−D ′
′|.
′ ′
∀j ∈ D − D , Q ⊆ I − IL − Pj . Since vj (Pj ) ≥ δVj , we get that ∀j ∈ D − D , vj (Q) ≤ (1 − δ)Vj .
Therefore, total number of boxes needed is at most 1+ |IL |+ |D − D ′ | ≤ 1+ |D ′ |+ |D − D ′ | ≤
|D| + 1.

28
Lemma 26. Given a packing of items I into m bins, we can round up the width of some non-
dense wide and big items in I to a multiple of ε21 /4 and round up the height of some non-dense
tall and big items in I to a multiple of ε21 /4 and repack the items into (d + 4)m ε-slacked bins
such that each bin satisfies either Property 11 or Property 12.

Proof. Let B1 , B2 , . . . , Bm be a packing of items I into m bins. For each bin Bk , we can use
Lemma 20 to round up some items in Bk and split Bk into bins Jk and Kk and boxes Wk and
Hk . W.l.o.g., assume Wk is a horizontal box. Put each box in a new bin. Then Wk satisfies
Property 12 and Hk satisfies Property 11.
Let Dk := {j ∈ [d] : vj (Jk ) > (1 − ε)}, Ek := {j ∈ [d] : vj (Kk ) > (1 − ε)}, Fk := {j ∈ [d] :
vj (Wk ) > (1 − ε)} and Gk := {j ∈ [d] : vj (Hk ) > (1 − ε)}. Dk , Ek , Fk and Gk are pairwise
disjoint and they are subsets of [d]. Now use Lemma 25 with parameter δ = ε on bin Jk with
dimensions Dk . This splits Jk into |Dk | + 1 ε-slacked bins. Similarly, by splitting Kk , Wk and
Hk , we get |Ek | + 1, |Fk | + 1 and |Gk | + 1 ε-slacked bins respectively.
The total number of bins from Bk is |Dk | + |Ek | + |Fk | + |Gk | + 4 ≤ d + 4. Therefore, we
get a total of (d + 4)m bins.
Jk , Kk , Wk and Hk satisfy the desired properties except possibly ε-slackness. When we split
a bin into multiple bins, the position of items relative to the bin isn’t changed. Therefore, the
split bins continue to satisfy these properties.

Lemma 27. Given a packing of items I, if item rotations are allowed, we can round up the
width of some non-dense wide and big items in I to a multiple of ε21 /4 and round up the height
of some non-dense tall and big items in I to a multiple of ε21 /4 and repack I into (d + 3)m
ε-slacked bins such that each bin satisfies Property 11.

Proof sketch. Use Lemma 24 on each bin in the packing to get 3 bins. The rest of the proof is
similar to Lemma 26.

We will now try to improve upon Lemmas 26 and 27 for the special case d = 1.

Lemma 28. Let there be m boxes of width 1 and height at most ε. Let the weight of each
box be at most kε in each dimension, where k ∈ {1, 2}. Then we can pack these boxes into
1 + m · kε/(1 − kε) bins such that the resulting bins are kε-slacked.

Proof. We can pack 1/kε − 1 boxes in 1 bin with the resulting bin being kε-slacked. This is
because the sum of weights is at most 1 − kε in each dimension and the total height of the boxes
is at most 1/k − ε ≤ 1. The total number of bins used is at most ⌈m/((1/kε) − 1)⌉ which in
turn is at most 1 + m · kε/(1 − kε).

The above lemma can also be used for vertical boxes, i.e. height 1 and width at most ε.

Lemma 29. Let d = 1. Let there be m boxes of width 1 and height at most ε containing only
non-big non-dense items. Let the weight of each box be at most 1/2. Then we can pack these
boxes into 2 + m (1/2 + ε/(1 − ε)) bins such that the resulting bins are ε-slacked.

Proof. Let i be an item in the box. Boxes only have non-big items, so a(i) ≤ ε2 . Boxes only
have non-dense items, so v1 (i) ≤ a(i)/ε21 ≤ ε/2.
From each box, choose the smallest prefix S for which v1 (S) ≥ ε/2. Then v1 (S) ≤ ε. Remove
S and put it in a new box of the same dimensions.
This gives us m boxes of weight at most (1 − ε)/2. We can pair them up and pack them
into ⌈m/2⌉ ≤ m/2 + 1 bins. Those bins will be ε-slacked.

29
 We also get m new boxes of weight at most ε. We can pack 1/ε − 1 such boxes into a bin.
This gives us at most 1 + m · ε/(1 − ε) bins. These bins are ε-slacked.


Total number of bins used is m 2 + 1 + (1 + m · ε/(1 − ε)) = 2 + m (1/2 + ε/(1 − ε)).

Lemma 30. Let d = 1. Let there be m boxes of width 1 and height δd . Suppose the boxes only
have dense items, and each box has total weight at least ε and at most 1/2. Then we can pack
the items of these boxes into at most 3 + 2m/3 bins such that the resulting bins are ε-slacked.

Proof. Let there be t boxes that have an item of weight at least 1/2 − 2ε. No item has weight
more than half. Therefore, we can pair up these high-weight items into at most t/2+ 1 ε-slacked
bins. In each of these t boxes, the remaining items have weight at most 2ε. Since ε ≥ δd , by
Lemma 28, we can pack them into 1 + 2εt/(1 − 2ε) number of ε-slacked bins.
m − t boxes have all items of weight less than 1/2 − 2ε. Each of these boxes has total weight
between ε and 1/2. Each box can be split into 2 boxes as follows: Order the items in a box
and find the smallest prefix of weight at least ε. Since there are no items of weight more than
1/2 − 2ε, such a prefix has weight between ε and 1/2 − ε.
Arrange the m − t boxes into groups of at most 3 boxes each. Let C1 , C2 , C3 be these boxes
in one such group. Split C1 and C2 into 2 boxes each by the above method. Let the resulting
boxes be C1′ , C1′′ , C2′ , C2′′ respectively. Assume w.l.o.g. that v1 (Cj′ ) ≤ v1 (Cj′′ ) for j ∈ [2]. Pack
C1′ , C2′ , C1′′ into 1 bin. It has weight at most 1 − ε, so it is ε-slacked. Pack C2′′ and C3 into 1 bin.
It has weight at most 1 − ε, so it is ε-slacked. Therefore, we can convert a group of 3 boxes into
2 ε-slacked bins.  
Total bins used is at most (1 + 2εt/(1 − 2ε)) + 2 ⌈(m − t)/3⌉ ≤ 3 + 2m/3 − t 32 − 1−2ε 2ε

which is at most 3 + 2m/3, assuming ε ≤ 1/5.

The above lemma can also be used for vertical boxes, i.e. height 1 and width at most δd .

Lemma 31. Given a packing of items I into m bins, when d = 1, we can round up the width of
some non-dense wide and big items in I to a multiple of ε21 /4 and round up the heightof some
1 ε
non-dense tall and big items in I to a multiple of ε21 /4 and repack I into 3 + 6 + 1−ε m + 12
ε-slacked bins such that each bin satisfies either Property 11 or Property 12.

Proof. Let B1 , B2 , . . . , Bm be a packing of items I into m bins. For each bin Bk , we can use
Lemma 20 to round up some items in Bk and split Bk into bins Jk and Kk and boxes Wk and
Hk , where Wk is a horizontal box and Hk is a vertical box, i.e. the width of Wk is 1 and the
height of Hk is 1.
Classifying bins:
We will now classify the bins B1 , B2 , . . . , Bm .
Type 1: v1 (Wk ) ≤ ε and v1 (Hk ) ≤ ε:
Among Jk and Kk , at most 1 bin will have weight more than 1 − ε. Use Lemma 25 to split
it into 2 bins. So for each original bin of type 1, we get at most 3 ε-slacked bins and 2 boxes,
one horizontal and one vertical, each of total weight at most ε.
Both Jk and Kk satisfy either Property 11 or Property 12. When we split a bin into multiple
bins, the position of items relative to the bin isn’t changed. Therefore, the bins continue to
satisfy these properties.
Type 2: v1 (Wk ) > ε and v1 (Hk ) ≤ ε:
v1 (Wk ) > ε implies that v1 (Jk ) ≤ 1 − ε and v1 (Kk ) ≤ 1 − ε, so Jk and Kk are already
ε-slacked. Pack Wk in a bin. Since v1 (Wk ) ≤ 1/2 ≤ 1 − ε, Wk is ε-slacked. Wk satisfies
Property 12. So for each original bin of type 2, we get at most 3 ε-slacked bins and 1 vertical
box of weight at most ε.

30
 Type 3: v1 (Wk ) ≤ ε and v1 (Hk ) > ε:
The analysis is similar to type 2. For each original bin of type 3, we get at most 3 ε-slacked
bins and 1 horizontal box of weight at most ε.
Type 4: v1 (Wk ) > ε and v1 (Hk ) > ε:
v1 (Wk ) > ε implies that v1 (Jk ) ≤ 1 − ε and v1 (Kk ) ≤ 1 − ε, so Jk and Kk are already
ε-slacked. So we have at most 2 ε-slacked bins and 2 boxes of weight at most 1/2.
Repacking boxes:
We will now try to pack the boxes into bins. Each of these bins packs some dense boxes and
some non-dense boxes. If multiple dense boxes were packed in a bin, we can use Lemma 23 to
repack them into a single dense box and move that box to an edge of the bin. Bins that only pack
horizontal boxes satisfy Property 12. Bins that only pack vertical boxes satisfy Property 11.
Among B1 , B2 , . . . , Bm , let there be mk bins of type k.
The number of ε-slacked bins is at most 3m1 + 3m2 + 3m3 + 2m4 ≤ 3m − m4 . We also have
m1 + m3 horizontal boxes and m1 + m2 vertical boxes of weight at most ε each. Since δd ≤
ε1 /2 ≤ ε and ε1 + ε2 ≤ 2ε/3 + 2ε3 /9 ≤ ε, each box has the smaller geometric dimension at most
ε
ε. By Lemma 28, the number of bins we need to pack them is at most 2 + 1−ε (2m1 + m2 + m3 ).
We have m4 horizontal boxes and m4 vertical boxes that each have weight between ε and
1/2. m4 of these are dense boxes and m4 are non-dense boxes.
The non-dense boxes don’t have big items.  Since
 ε ≥ ε1 + ε2 , by Lemma 29, the number of
1 ε
bins needed to pack them is at most 4 + 2 + 1−ε m4 .
By Lemma 30, we can pack the dense boxes into 6 + 2m4 /3 bins, where each bin is ε-slacked.
The total number of bins used is at most
       
ε 1 ε 2
(3m − m4 ) + 2 + (2m1 + m2 + m3 ) + 4 + + m4 + 6 + m4
1−ε 2 1−ε 3
 
1 ε ε m4 − m
= 12 + 3 + + m+ m1 +
6 1−ε 1−ε 6
   
1 ε 1 ε
≤ 12 + 3 + + m− − m1 (m4 ≤ m − m1 )
6 1−ε 6 1−ε
 
1 ε
≤ 12 + 3 + + m. (ε ≤ 1/8)
6 1−ε

Lemma 32. Given a packing of items I into m bins, when d = 1 and item rotations are allowed,
we can round up the width of some non-dense wide and big items in I to a multiple of ε21 /4 and
round up 2
 the height
 of some non-dense tall and big items in I to a multiple of ε1 /4 and repack
ε
I into 3 + 1−ε m + 1 ε-slacked bins such that each bin satisfies Property 11.

Proof sketch. Using techniques from the proof of Lemma 31, we get at most 3m ε-slacked bins
and at most m vertical boxes, where each box has total weight at most ε. Using Lemma 28, we
get the desired results.

We can summarize Lemmas 26, 27, 31 and 32 as follows:

Theorem 33. Given a packing of I into m bins, we can round up the width of some non-dense
wide and big items in I to a multiple of ε21 /4 and round up the height of some non-dense tall
and big items in I to a multiple of ε21 /4 and repack I into at most am + b ε-slacked bins such
that each bin satisfies either Property 11 or Property 12. Here the values of a and b depend on
the value of d and whether item rotations are allowed. See Table 2.

31
 Table 2: Values of a and b for Theorem 33.

a b Lemma
rotations forbidden d+4 0 Lemma 26
rotations allowed d+3 0 Lemma 27
1 ε
rotations forbidden and d = 1 3+ + 12 Lemma 31
6 1−ε
ε
rotations allowed and d = 1 3+ 1 Lemma 32
1−ε

F.4 Rounding Weights

Definition 15 (Weight classes). Two items i1 and i2 are said to belong to the same weight
class iff one of these conditions hold:

• i1 and i2 are big and ∀j ∈ [d], vj (i1 ) = vj (i2 )

• i1 and i2 are non-dense and wide and ∀j ∈ [d], vj (i1 )/h(i1 ) = vj (i2 )/h(i2 ).
• i1 and i2 are non-dense and tall and ∀j ∈ [d], vj (i1 )/w(i1 ) = vj (i2 )/w(i2 ).
• i1 and i2 are non-dense and small and ∀j ∈ [d], vj (i1 )/a(i1 ) = vj (i2 )/a(i2 ).
• i1 and i2 are dense and light and ∀j ∈ [d], vj (i1 )/vmax (i1 ) = vj (i2 )/vmax (i2 ).
• i1 and i2 are dense and heavy and ∀j ∈ [d], vj (i1 ) = vj (i2 ).

Big items that have the same geometric dimensions and the same weight class are identical.
We will round the geometric dimensions of dense items to 0, so heavy items of the same weight
class would be identical.

Definition 16 (Slicing and fractional packing). Let I be a set of items. Ib is called a slicing of
I iff Ib can be obtained from I by one or more of the following operations:

• Horizontally slicing a non-dense wide item (i.e. if a wide item i is sliced into items i1 and
i2 , then w(i) = w(i1 ) = w(i2 ) and h(i) = h(i1 ) + h(i2 )).
• Vertically slicing a non-dense tall item (i.e. if a tall item i is sliced into items i1 and i2 ,
then h(i) = h(i1 ) = h(i2 ) and w(i) = w(i1 ) + w(i2 )).
• Slicing a non-dense small item in one or both dimensions.
• Slicing a light dense item of zero area.

A packing of Ib into bins is called a fractional packing of I.

Wide non-dense items of the same width and of the same weight class can be used inter-
changeably while trying to get a fractional packing. Similarly, tall non-dense items of the same
height and of the same weight class are interchangeable, small non-dense items of the same
weight class are interchangeable and light dense items of zero area and the same weight class
are interchangeable.
We will now see how to round the weights of items so that they belong to a constant number
of weight classes.

F.4.1 Rounding Weights of Non-Dense Items

Transformation 17. Given an item i, ∀j ∈ [d],

• If i is big, round up vj (i) to a positive multiple of ε21 ε/8.

• If i is wide and non-dense, round up vj (i) to a positive multiple of h(i)ε1 ε/8.
• If i is tall and non-dense, round up vj (i) to a positive multiple of w(i)ε1 ε/8.

32
 • If i is small and non-dense, round up vj (i) to a positive multiple of a(i)ε/8.

Lemma 34. Transformation 17 is valid, i.e. for any item i, ∀j ∈ [d], vj (i) ≤ 1 after the
transformation.

Proof. Since ε−1

1 ,ε
−1 ∈ Z, the transformed weight of a big item can be at most 1.

Since ε2 ≤ (1 − ε)ε21 , the weight of a non-dense wide/tall/small item is at most ε2 /ε21 ≤ 1 − ε

and rounding it up can only increase it by at most ε/8.

Lemma 35. Let a bin J be µ-slacked, for ε/8 ≤ µ ≤ ε. Then after applying Transformation 17,
the bin will be (µ − ε/8)-slacked.

Proof. If the bin contains a single item, it will remain µ-slacked after the transformation.
Suppose the bin contains multiple items, then ∀j ∈ [d], vj (J) ≤ 1 − µ. Let there be p big
items. Let the total height of wide non-dense items be H. Let the total width of tall non-dense
items be W . Let the total area of small non-dense items be A.
The total area of big items is at least pε21 , of wide items is at least ε1 H and of tall items is
at least ε1 W . Since the total area of items in J is at most 1,

ε21 p + ε1 H + ε1 W + A ≤ 1.

The total increase in vj (J) is at most

ε 2 ε
(ε1 p + ε1 H + ε1 W + A) ≤ .
8 8
Therefore, the resulting bin is (µ − ε/8)-slacked.

Observation 36. Since we’re rounding up weights of non-dense items in Transformation 17,
some items may not continue to satisfy the non-denseness property, i.e. vj (i)/a(i) may exceed
1/ε21 for some items i and some j ∈ [d].
However, this will not affect us much. Formally:

a Big items will remain non-dense, since a(i) > ε21 and vmax (i) ≤ 1.

b Small items will remain non-dense, since vmax (i)/a(i) will be rounded up to a multiple of
ε/8, and ε/8 divides 1/ε21 .

c For wide items, vmax (i)/a(i) may rise to at most 1/ε21 + ε/8. Furthermore, vmax (i)/h(i)
will be rounded to a multiple of ε1 ε/8, and ε1 ε/8 divides 1/ε21 , so vmax (i)/h(i) will continue
to be at most 1/ε21 .

d For tall items, vmax (i)/a(i) may rise to at most 1/ε21 +ε/8. Furthermore, vmax (i)/w(i) will
be rounded to a multiple of ε1 ε/8, and ε1 ε/8 divides 1/ε21 , so vmax (i)/w(i) will continue
to be at most 1/ε21 .

Even if vmax (i)/a(i) of some non-dense items exceeds 1/ε21 after Transformation 17, we will
continue to consider them non-dense items.

d
d
d
Lemma 37. Define nbwc := 8/(ε21 ε) , nwwc := 8/(ε31 ε) , nswc := 8/(ε21 ε) . After Trans-
formation 17, the number of weight classes of big items is at most nbwc , of wide non-dense items
is at most nwwc , of tall non-dense items is at most nwwc and of small non-dense items is at
most nswc .

33
F.4.2 Rounding Weights of Dense Items

Transformation 18. For item i, if i is non-dense, do nothing. If i is dense, set w(i) and h(i)
to 0 and for each j ∈ [d], if vj (i) ≤ (ε/8d)vmax (i), then set vj (i) to 0.
Since Transformation 18 rounds down weights, we need to prove that we can easily undo
this transformation.
Lemma 38. Let J be a set of items. Let J ′ be the items obtained by applying Transformation 18
to J. Suppose we’re given a packing of J ′ into a bin that satisfies Property 11b and is µ-slacked,
for some µ ≥ ε/8.
Then there is a polynomial-time algorithm to convert the packing of J ′ into a packing of
J that satisfies Property 11b, is (µ − ε/8)-slacked, and the position of non-dense items in the
packing of J is the same as the position of non-dense items in the packing of J ′ .
(Analogous lemma holds for Property 12b)

Proof. By Lemma 23, we can always pack dense items in J in polynomial time into a box of
′
height 1 and width δd . Since δd ≤ ε1 /2, this box fits in S (R ) . Therefore, Property 11b is
satisfied.
Now we will prove that the packing of J is (µ − ε/8)-slacked. There are 3 cases to consider:
Case 1: ∀j ∈ [d], vj (J ′ ) ≤ 1 − µ:
For each j ∈ [d] and each dense item i, reverting the transformation increases vj (i) by at most
(ε/8d)vmax (i). So by Claim 18, we get
ε ε  ε
vj (J) ≤ vj (J ′ ) + vmax (J ′ ) ≤ vj (J ′ ) + ≤ 1 − µ − .
8d 8 8
Therefore, J is (µ − ε/8)-slacked.
Case 2: |J ′ | = 1:
Then |J| = 1, so J is µ-slacked.
Case 3: |J ′ | = 2 and J ′ only has dense items and ∀i ∈ J ′ , 1/2 − µ ≤ vmax (i) ≤ 1/2:
The 0-value dimensions of i increase to (ε/8d)vmax (i) ≤ vmax (i), so vmax (i) remains the same
across this transformation. So J is µ-slacked.

As the first step in rounding dense items, we apply Transformation 18 to I.

Since ε1 ≤ 1/4d, we get ε2 ≤ (ε/8d)ε1 . Hence, Transformation 18 forces heavy items to be
heavy in all non-zero dimensions.
Now we will use different transformations on heavy and light items.
Transformation 19. For a dense item i, if vj (i) > ε1 , round up vj (i) to a multiple of ε1 ε/8.
Lemma 39. Let J be a packing of items into a bin that is µ-slacked, for some µ ≥ ε/8. Let
J ′ be the packing obtained by applying Transformation 19 to dense items in J. Then J ′ is a
(µ − ε/8)-slacked packing.

Proof. Case 1: ∀j ∈ [d], vj (J ′ ) ≤ 1 − µ:

For each j ∈ [d], there are less than ε−1 1 items i in J such that vj (i) > ε1 . For each such
item, vj (i) increases by less than ε1 ε/8. Therefore, vj (J ′ ) < vj (J) + ε/8. Therefore, J is
(µ − ε/8)-slacked.
Case 2: |J| = 1:
|J ′ | = 1, so J ′ is µ-slacked.
Case 3: |J| = 2 and J only has dense items and ∀i ∈ J, 1/2 − µ ≤ vmax (i) ≤ 1/2:
−1 −1
ε1 ε ∈ Z, so 1/2 is a multiple of ε1 ε/8. Therefore, for each item i, vmax (i) increases to at
most 1/2. So J is µ-slacked.

34
Lemma 40. The number of distinct heavy items after Transformation 19 is at most
  d
8 1
nhwc := −1 .
ε ε1

Proof. This is because large vector dimensions are rounded to at most 8/ε1 ε − 8/ε distinct
values.
Transformation 20. For a dense item i, if vmax (i) ≤ ε2 , then for each j ∈ [d], round up
vj (i)/vmax (i) to a power of 1/(1 + ε/8) if vj (i) > 0.
Lemma 41. Let J be a packing of items into a bin that is µ-slacked, for some ε/8 ≤ µ ≤ ε.
Let J ′ be the packing obtained by applying Transformation 20 to dense items in J. Then J ′ is
a (µ − ε/8)-slacked packing.

Proof. Case 1: ∀j ∈ [d], vj (J ′ ) ≤ 1 − µ:

For each j ∈ [d], vj (i) increases by a factor of at most 1 + ε/8. So,
 ε ε
′
vj (J ) ≤ vj (J) 1 + ≤ vj (J) + .
8 8
Therefore, J ′ is (µ − ε/8)-slacked.
Case 2: |J| = 1:
vmax (i) ≤ 1 after the transformation, so the packing is valid and |J ′ | = 1. Therefore, J ′ is
µ-slacked.
Case 3: |J| = 2 and J only has dense items and ∀i ∈ J, 1/2 − µ ≤ vmax (i) ≤ 1/2:
Since ε2 ≤ 1/2 − ε ≤ 1/2 − µ and the transformation only applies when vmax (i) ≤ ε2 , J remains
the same after the transformation.
Lemma 42. After Transformation 20, the number of distinct values of the weight vector of
light items is at most
    d−1
ln(8d/ε) d−1 8+ε 8d
≤ ln := nlwc
ln(1 + ε/8) ε ε

Proof. This is because vj (i)/vmax (i) is lower-bounded by ε/8d because of Transformation 18.
Transformation 21 (Weight-rounding). For a set I of items, weight-rounding is the process
of applying Transformations 17, 18, 19 and 20 to all items. A set I of items is said to be
weight-rounded iff I is invariant under Transformations 17, 18, 19 and 20.

F.5 Rounding the Other Side

So far, for each item, we seen how to round their weights and how to round one geometric
dimension. In this subsection, we will see how to use linear grouping to round the other
geometric dimension. We will show that after this operation, the items will belong to a constant
number of homogeneous classes (see Condition C1.3 in Section 4.2).

F.5.1 Rounding Geometric Dimensions of Non-Dense Items

Transformation 22 (Linear grouping). Suppose we are given a packing of items I into m bins,
where I is invariant under Transformation 17 and each bin satisfies Property 11a.
Partition the big items in I by their width and weight class. Partition the tall non-dense
items in I by their weight class. The number of partitions is constant by Property 11a and
−1
Lemma 37. Let δlg := εε1 /(d + 1) (so δlg ∈ Z).
For each partition S of big items, do the following:

35
 1. Order the items in S in non-increasing order of height.

2. Let k := ⌊δlg |S|⌋ + 1. Let S1 be the first k items, S2 be the next k items, and so on, till
ST , where T = ⌈|S|/k⌉ ≤ 1/δlg . For t ∈ [T ], St is called the tth linear group of S. The
first item in St is called the leader of St , denoted as leader(St ).

3. Increase the height of each item in S1 to h(leader(S1 )). Unpack the items S1 −{leader(S1 )}.

4. For each t ∈ [T ] − {1} and each j ∈ [|St |] − {1}, let i be the j th item in St and let i′ be the
j th item in St−1 . Note that h(i′ ) ≥ h(leader(St )) ≥ h(i). Increase h(i) to h(leader(St ))
and pack i where i′ was packed. Since i has the same width and weights as i′ , the geometric
constraints are not violated and the total weights of the bin do not increase. The number
of distinct heights in S now becomes at most T ≤ 1/δlg .

For each partition S of tall items, do the following:

1. Order the items in S in non-increasing order of height and arrange them side-by-side on
the real line, starting from the origin.

2. Let the total width of S be W . Let St be the items in the interval [(t − 1)δlg W, tδlg W ].
Slice the items if they lie on the boundaries of the interval. St is called the tth linear group
of S. The first item in St is called the leader of St , denoted as leader(St ).

3. Increase the height of each item in S1 to h(leader(S1 )). Then unpack S1 .

4. For each t ∈ [1/δlg ] − {1}, move the items in St to the space occupied by St−1 (items in St
may need to be sliced for this) and increase the height of each item i ∈ St to h(leader(St )).
This doesn’t violate geometric constraints since St and St−1 have the same total width
and this doesn’t increase the total weights of the bin because all items in S have the same
weight class. The number of distinct heights in S now becomes at most 1/δlg .

We can extend the definition of this transformation to bins satisfying Property 12a by swap-
ping vertical and horizontal directions. (Partition big items by height and weight class and
partition wide items by weight class. Then round up the width of items in each partition using
the above techniques.)

Lemma 43. Let  J be a set of big 

and tall items and let µ ∈ [0, 1) be a constant. Define
vmax (i) P
span (i) := max w(i), min 1−µ , 1 . Then i∈J span′ (i) ≤ 1 implies J can be packed into
′

a µ-slacked bin where all items touch the bottom of the bin.
P P ′
Proof. i∈J w(i) ≤ i∈J span (i) ≤ 1.
∀i ∈ J, span′ (i) > 0. So if span′ (i) = 1 for some i ∈ J, then |J| = 1. So J can be packed
into a bin, and the bin is µ-slacked since |J| = 1.
Now let span′ (i) < 1 for all i ∈ J. So vmax (i) < 1 − µ and ∀j ∈ [d],
X X vmax (i) X
vj (J) = vj (i) ≤ (1 − µ) ≤ (1 − µ) span′ (i) ≤ 1 − µ.
1−µ
i∈J i∈J i∈J

Therefore, J can be packed into a µ-slacked bin.

Lemma 44. Suppose we are given a packing of items I into m bins, where I is invariant under
Transformation 17 and each bin satisfies Property 11a. Let U be the items unpacked by linear
2ε
grouping (Transformation 22). Then U can be repacked into 1−ε m + 1 number of ε-slacked bins
that satisfy Property 11.

36
   
Proof. Define span′ (i) := max w(i), min vmax
1−ε
(i)
, 1 . Let K be the set of big and tall non-
P
dense items in I. For any J ⊆ K, define span (J) := i∈J span′ (i).
′

Interpret each item i ∈ U as a 1D item of size span′ (i). Order the items such that big items
in U appear before tall non-dense items in U . Pack them on the bottom of new bins using
the Next-Fit algorithm. By Lemma 43, they will require at most 2 span′ (U ) + 1 ε-slacked bins.
These bins satisfy Property 11a since the width of all big items in U is a multiple of ε21 /4, and
they satisfy Property 11b since U only contains non-dense items.
In Transformation 22, we partitioned all big items in I by width and weight class. Let S ⊆ I
be one such partition. Given the way we created the groups S1 , S2 , . . ., we get |S ∩ U | ≤ ⌊δlg |S|⌋.
Since all items in S have the same width and weights, span′ (i) is the same for each i ∈ S.
Therefore,
span′ (S ∩ U ) = span′ (i)|S ∩ U | ≤ span′ (i) ⌊δlg |S|⌋ ≤ δlg span′ (S).
In Transformation 22, we partitioned all tall non-dense items in I by weight class. Let S ⊆ I be
one such partition. Given the way we created the groups S1 , S2 , . . ., we get w(S ∩ U ) = δlg w(S).
All items in S have the same weights-to-width ratio, which is at most 1/ε21 by Observation 36d.
Since ε2 ≤ ε21 (1 − ε), we get vj (i) ≤ 1 − ε for all i ∈ S, so span′ (i)/w(i) is the same for each
i ∈ S. Let that common ratio be α. Then,
span′ (S ∩ U ) = αw(S ∩ U ) ≤ αδlg w(S) = δlg span′ (S).
Summing over all partitions S, we get
X X
span′ (U ) = span′ (U ∩ S) ≤ δlg span′ (S) ≤ δlg span′ (K). (1)
S S

For i ∈ K, we get
 
span′ (i) max w(i), vmax
1−µ
(i) 1
max (w(i), vmax (i)) 1
1−µ
≤ ≤ ≤ .
span(i) max (w(i)h(i), vmax (i)) max (w(i)ε1 , vmax (i)) (1 − µ)ε1
The last inequality follows because for big and tall items, h(i) ≥ ε1 .
The number of bins used to pack U is
2δlg
2 span′ (U ) + 1 ≤ 2δlg span′ (K) + 1 ≤ span(K) + 1
ε1 (1 − ε)
2(d + 1)δlg 2ε
≤ m+1= m + 1.
ε1 (1 − ε) 1−ε
The first inequality follows from (1) and the third inequality follows from Claim 18.

Lemma 45. Suppose we are given a packing of items I into m bins, where I is weight-rounded,
each bin is µ-slacked for some µ ≤ ε, and each bin satisfies either Property 11 or Property 12.
Then after applying linear grouping (Transformation 22) to this packing of I, we get a packing
of items Ib into m′ bins, where all of the following hold:

• Ib is a rounding-up of I and contains a constant number of homogeneous classes (see

Condition C1.3 in Section 4.2).
• Each bin in the packing of Ib is µ-slacked and satisfies either Property 11 or Property 12.
 
′ 2ε
• m ≤ 1+ m + 2.
1−ε

Proof sketch. Follows from the definition of linear grouping and Lemma 44. Note that we apply
linear grouping separately to bins satisfying Property 11 and bins satisfying Property 12.

37
F.5.2 Coarse and Fine Partitioning

Our approach so far has been to start from an optimal packing of items and show how to modify
it to obtain an approximately-optimal structured packing of a rounded instance. However,
the rounding algorithm must round items without knowing the optimal packing. To design
such an algorithm, we first need to introduce additional concepts: coarse partitioning and fine
partitioning.
At a high level, our rounding algorithm first partitions the items by weight classes to get a
coarse partitioning. It then further partitions the coarse partitions to get a fine partitioning. It
then rounds up the geometric dimensions of items in each fine partition to make that partition
homogeneous.
We will first formally define coarse and fine partitioning. We will then restate Theorem 33
and Lemma 45 using the language of fine partitioning. Then in Appendix F.6, we will see an
algorithm for computing a fine partitioning of I.

• Let B(I) be the set of big items in I.

• Let W (I) be the set of wide non-dense items in I.
• Let H(I) be the set of tall non-dense items in I.
• Let S(I) be the set of small non-dense items in I.
• Let D l,1 (I) be the set of light dense items in I that are either tall or small.
• Let D l,2 (I) be the set of light dense wide items in I.
• Let D h,1 (I) be the set of heavy dense items in I that are either tall or small.
• Let D h,2 (I) be the set of heavy dense wide items in I.

When the set of items I is clear from context, we will use B, W , H, S, D l,1 , D l,2 , D h,1 , D h,2
to refer to these sets.
Definition 23 (Coarse partitioning). Let I be a weight-rounded instance. Partition items I by
their weight classes. Then for each partition containing dense items, split that partition into 2
partitions: one containing only tall and small items and the other containing only wide items.
The resulting partitioning is called a coarse partitioning of I.
We number the coarse partitions in B arbitrarily from 1 onwards. There will be at most
nbwc such partitions by Lemma 37. Denote the pth coarse partition by Bp .
Similarly, denote the pth coarse partition

• in W by Wp , where p ∈ [nwwc ].
• in H by Hp , where p ∈ [nwwc ].
• in S by Sp , where p ∈ [nswc ].
• in D l,1 by Dpl,1 , where p ∈ [nlwc ].
• in D l,2 by Dpl,2 , where p ∈ [nlwc ].
• in D h,1 by Dph,1 , where p ∈ [nhwc ].
• in D h,2 by Dph,2 , where p ∈ [nhwc ].
Observation 46. There is a unique coarse partitioning of I. Furthermore, the unique coarse
partitioning can be found in O(|I|) time.

In Theorem 33 and Lemma 45, widths of wide and big items are rounded. The rounding is
different for Theorem 33 and Lemma 45: In Theorem 33, we round the widths of some items to
multiples of ε21 /4 so that the bin satisfies Property 11a, and in Lemma 45, we round the widths
of items in bins satisfying Property 12a using linear grouping. To get a rounding algorithm, we
have to guess whether the bin of a wide or big item will satisfy Property 11 or Property 12. We
will capture these guesses in the fine partitioning.

38
 h i n o
4
Definition 24 (Fine partitioning). Let Q := Z ∩ ε1 + 1, ε42 , R := 1, 2, . . . , δ1lg , Qq :=
n o 1
ε2 ε2
x ∈ R : (q − 1) 41 < x ≤ q 41 .
Given a coarse partitioning of a set I of items, let (Bpw , Bph ) be a partitioning of Bp ,
(Wpw , Wph ) be a partitioning of Wp and (Hpw , Hqh ) be a partitioning of Hp .

• Bpw is partitioned into sets {Bp,q,r

w w
: q ∈ Q, r ∈ R} where i ∈ Bp,q,r =⇒ w(i) ∈ Qq .

• Bph is partitioned into sets {Bp,q,r

h h
: q ∈ Q, r ∈ R} where i ∈ Bp,q,r =⇒ h(i) ∈ Qq .

• Wpw is partitioned into sets {Wp,q

w : q ∈ Q} where i ∈ W w =⇒ w(i) ≤ qε2 /4.
p,q 1

• Wph is partitioned into sets {Wp,r

h : r ∈ R}.

• Hpw is partitioned into sets {Hp,r

w : r ∈ R}.

• Hph is partitioned into sets {Hp,q

h : q ∈ Q} where i ∈ H h =⇒ h(i) ≤ qε2 /4.
p,q 1

w , Bh
A fine partitioning of I is any partitioning of I into sets of the form Bp,q,r w
p,q,r , Wp,q ,
l,1
h , Hw , Hh , S , D , D , D l,2 h,1 h,2
Wp,r p,r p,q p p p p , Dp .

Note that for a given set I of items, there can be multiple fine partitionings.
Given a fine partitioning, we use the ‘∗’ character Sin superscript or subscript
S to wdenote
the union of some partitions. For example, Bp,∗,r w w
:= q Bp,q,r and W∗,∗w :=
p,q Wp,q , and
∗,1 l,1 h,1
Dp := Dp ∪ Dp .
When item rotations are allowed, the fine partitioning includes information on which items
to rotate, and we can assume w.l.o.g. that H(I) = D ∗,2 = B∗,∗,∗
h = W∗,∗h = H h = {}.
∗,∗

Transformation 25. Given a fine partitioning of I, execute the following operations:

w
• ∀i ∈ B∗,q,∗ w , increase w(i) to qε2 /4.
∪ W∗,q 1

h
• ∀i ∈ B∗,q,∗ h , increase h(i) to qε2 /4.
∪ H∗,q 1
w , increase h(i) to max
• ∀i ∈ Bp,q,r w h(i).
i∈Bp,q,r

h
• ∀i ∈ Bp,q,r , increase w(i) to maxi∈Bp,q,r w(i).
h

h , increase w(i) to max

• ∀i ∈ Wp,r h w(i).
i∈Wp,r

w , increase h(i) to max

• ∀i ∈ Hp,r w h(i).
i∈Hp,r

The number of fine partitions is constant and after applying Transformation 25, each parti-
tion is homogeneous.

Definition 26 (Semi-structured packing of fine partitioning). Suppose we are given a fine

partitioning of items I. A packing of items J ⊆ I into a bin is said to be ‘division-1 semi-
h
structured’ with respect to the fine partitioning iff J doesn’t contain items from B∗,∗,∗ h ,
, W∗,∗
h and D ∗,2 and J satisfies Property 11.
H∗,∗
A packing of items J ⊆ I into a bin is said to be ‘division-2 semi-structured’ with respect to
w , W w , H w and D ∗,1 and J satisfies
the fine partitioning iff J doesn’t contain items from B∗,∗,∗ ∗,∗ ∗,∗
Property 12.
Packing of items into bins is called semi-structured iff each bin is either division-1 semi-
structured or division-2 semi-structured.

39
Definition 27 (Balanced fine partitioning). A fine partitioning is said to be balanced iff it
satisfies all of the following conditions:
h ) = δ h(W h )
• ∀p, ∀r, h(Wp,r lg p,∗
w ) = δ w(H w )
• ∀p, ∀r, w(Hp,r lg p,∗
w
• ∀p, ∀q, the sets {Bp,q,r w
: ∀r} can be obtained from Bp,q,∗ w
by ordering the items in Bp,q,∗ in
non-increasing order of height (breaking ties arbitrarily)and putting the first k items in
w , the next k items in B w , and so on, where k := δ |B w | + 1.
Bp,q,1 p,q,2 lg p,q,∗

h
• ∀p, ∀q, the sets {Bp,q,r h
: ∀r} can be obtained from Bp,q,∗ h
by ordering the items in Bp,q,∗ in
non-increasing order of width (breaking ties arbitrarily) and putting  the first k items in
h
Bp,q,1 h
, the next k items in Bp,q,2 h
, and so on, where k := δlg |Bp,q,∗ | + 1.
We now restate Theorem 33 and Lemma 45 in terms of fine partitioning.
Lemma 47. Let I be a set of items and Ib be the items obtained by weight-rounding I. Then there
exists a balanced fine partitioning of a slicing of Ib such that after applying
 Transformation
 25
b b 2ε
to I, there is a semi-structured (5ε/8)-slacked fractional packing of I into 1 + 1−ε (a opt(I) +
b) + 2 bins. Here a and b are as defined in Table 2 in Theorem 33.

Proof. By Theorem 33, we can round up the width of some big and wide non-dense items in I
to the nearest multiple of ε21 /4 and round up the height of some big and tall non-dense items
in I to the nearest multiple of ε21 /4 and then pack I into a opt(I) + b ε-slacked bins such that
each bin satisfies either Property 11 or Property 12. Let B be such a bin packing of I. By
Lemmas 35, 39 and 41, B gives us a (5ε/8)-slacked packing of I. b
Call the bins in B that satisfy Property 11 division-1 bins. Call the rest of the bins division-2
bins. The items whose width needs to be rounded up to a multiple of ε21 /4 are the big and wide
items in division-1 bins and the items whose height needs to be rounded up to a multiple of
ε21 /4 are the big and tall items in division-2 bins. No other items need to have their width or
height rounded up in the packing B produced by Theorem 33.
Let Ibw and Ibh be the items of Ib in division-1 bins and division-2 bins respectively.
We can compute the coarse partitioning of I. b Define

Bpw := Bp ∩ Ibw Wpw := Wp ∩ Ibw Hpw := Hp ∩ Ibw

B h := Bp ∩ Ibh
p W h := Wp ∩ Ibh
p H h := Hp ∩ Ibh
p

Define
• w := {i ∈ B w : (q − 1)ε2 /4 < w(i) ≤ qε2 /4}.
Bp,q p 1 1
• h := {i ∈ B h : (q − 1)ε2 /4 < h(i) ≤ qε2 /4}.
Bp,q p 1 1
• w := {i ∈ W w : (q − 1)ε2 /4 < w(i) ≤ qε2 /4}.
Wp,q p 1 1
• h := {i ∈ H h : (q − 1)ε2 /4 < h(i) ≤ qε2 /4}.
Hp,q p 1 1

Define
• w
Bp,q,r as the r th linear group of Bp,q
w (see Transformation 22).

• h th
Bp,q,r as the r linear group of Bp,q h .

• h as the r th linear group of W h .

Wp,r p
• w as the r th linear group of H w .
Hp,r p

b
This is how we get a fine partitioning of a slicing of I.
As per Lemma b
 45, on applying Transformation 25 to I, the resulting instance can be sliced
2ε
and packed into 1 + 1−ε (a opt(I) + b) + 2 number of (5ε/8)-slacked bins.

40
F.6 Rounding Algorithm
Let I be a set of weight-rounded items. To use Lemma 47 to get an approximately-optimal
packing of items I, we would like to iterate over all balanced fine partitionings of slicings of
I. However, even if we don’t consider slicings, doing that will take exponential time, since for
each big, wide and tall item, we need to decide whether to designate it as a division-1 item or
a division-2 item.
We can get around this problem by iterating over a polynomial-sized set SΠ of fine partition-
ings such that each balanced fine partitioning P of a slicing of I is ‘close to’ a fine partitioning
Pb in SΠ . We will now define what we mean by ‘close to’.

Definition 28 (Predecessor of a set of items). Let I1 and I2 be sets of items. Interpret each
item i ∈ I1 as a bin whose geometric dimensions are the same as that of i and whose weight
capacities are the same as the weights of i. I2 is said to be a predecessor of I1 (denoted as
I2  I1 ) iff I2 can be sliced and packed into I1 .

We will design a polynomial-time algorithm iter-fine-parts that takes as input a weight-

rounded set I of items and outputs a set SΠ of pairs such that for each balanced fine partitioning
b ∈ SΠ such that all of these conditions hold:
P of a slicing of I, there exists a pair (D, P)

• Pb is a fine partitioning of I − D.

• After applying Transformation 25, each partition in Pb is a predecessor of the corresponding

partition in P.

• D is a set of non-dense items (called discarded items) such that span(D) is small compared
to span(I).

F.6.1 Big Items

Let part-big be an algorithm that takes a coarse partition Bp of big items as input, and outputs
multiple fine partitionings of Bp . We can use part-big as a subroutine in iter-fine-parts.
To design part-big, we will guess the cardinality of sets Bp,q,rw h
and Bp,q,r . We will then
w h
guess the maximum height in Bp,q,r and the maximum width in Bp,q,r . Then for each guess, we
will solve a max-flow problem to check if items in Bp can be assigned to these sets. We skip the
details here since this approach is similar to that of Prädel (see Section 3.3.1 in [39]).
Formally part-big(Bp ) outputs a set of pairs of the form ({}, P), b where P b is supposed to
be a fine partitioning of Bp .

 3

Claim 48. part-big(Bp ) generates O n2|Q|(1/δlg +1)−1 = O n8(d+1)/εε1 values, where n :=
|Bp |, and the running time per value is O(n2 /εε1 ).

Claim 49. Let P := {Bp,q,rw h

: ∀q, ∀r} ∪ {Bp,q,r : ∀q, ∀r} be a balanced fine partitioning of Bp .
b
Then there is an output ({}, P ) of part-big(Bp ) where P b := {Bbp,q,r
w bp,q,r
: ∀q, ∀r} ∪ {B h : ∀q, ∀r}
b
such that P is a fine partitioning of Bp and after applying Transformation 25,

b w  B w and B
∀q, ∀r, B bh  Bh .
p,q,r p,q,r p,q,r p,q,r

part-big for the rotational case is similar to the non-rotational case: When rotations are
h
allowed, assume w.l.o.g. that B∗,∗,∗ = {}. We will guess the cardinality and maximum height
w
in sets Bp,q,r . Then for each guess, we will solve a max-flow problem to check if items in Bp can
be assigned to these sets, possibly after rotating some items.

41
F.6.2 Wide and Tall Items

Let part-wide be an algorithm that takes a coarse partition Wp of wide items as input,
and outputs multiple fine partitionings of Wp . We can use part-wide as a subroutine in
iter-fine-parts.
w : ∀q} ∪ {W h : ∀r} be a balanced fine partitioning of a slicing of W . We
Let P := {Wp,q p,r p
b c w c h
want part-wide to find a fine partitioning P := {Wp,q : ∀q} ∪ {Wp,r : ∀r} of a large subset
of Wp such that after applying Transformation 25 to P and P, b every fine partition in Pb is a
predecessor of the corresponding fine partition in P.
P
For any J ⊆ Wp , define h(J) := i∈J h(i) and w(J) := maxi∈J w(i). We will create a
rectangular box for each
h fine partition
i and then try to pack a large subset of Wp into these
4 4
boxes. Let Q := Z ∩ ε1 + 1, ε2 . For each q ∈ Q, let sw 2
q be a box of width qε1 /4 and height
1
h(Wp,qw ). For each r ∈ [1/δ ], let sh be a box of width w(W h ) and height h(W h ). Since we
lg r p,r p,r
don’t know Wp,r h and W w , we will guess the value of w(W h ) and we will guess very close lower
p,q p,r
bounds on h(Wp,q w ) and h(W h ). We will then try to pack most of the items from W into these
p,r p
boxes.
Let W cp,q
w be the items packed into sw and let W
q
cp,r
h be the items packed into sh . Then
r
Pb := {Wcp,q
w : ∀q} ∪ {Wcp,r
h : ∀r} is a fine partitioning of a large subset of W . After applying
p
Transformation 25 to P and P, b each item in Wp,q
w and Wcp,q
w has width qε2 /4. Since h(W cp,q
w ) ≤
1
h(sw w cw w
q ) ≤ h(Wp,q ), we get Wp,q  Wp,q after Transformation 25. We can similarly prove that
c h  W h . Therefore, Pb is a suitable fine partitioning.
W p,r p,r
The details on how to approximately guess the size of boxes and how to pack a large subset
of items into boxes can be deduced from section 3.3.1 of [39].
Formally, part-wide(Wp ) outputs a set of pairs of the form (D, P),b where items in D are
called discarded items and Pb is supposed to be a fine partitioning of Wp − D.
b of part-wide(Wp ),
Claim 50. For every output (D, P)
 
d+1 4 4
h(D) ≤ (3ε2 ) + 2− .
εε1 ε1 ε1
w : ∀q} ∪ {W h : ∀r} be a balanced fine partitioning of a slicing of W .
Claim 51. Let P := {Wp,q p,r p
b of part-wide(Wp ), P
Then for some output (D, P) b is a fine partitioning of Wp − D and after
b
applying Transformation 25 to P and P,
cp,q
(∀q, W w w
 Wp,q cp,r
) and (∀r, W h h
 Wp,r ).

Claim 52. Let there be n items in Wp . Let nq := 4/ε21 − 4/ε1 . Then part-wide(Wp ) outputs
at most δlg nnq +1+1/δlg distinct values. The running time per value is O(n log n).

part-wide can analogously be used for sub-partitioning coarse partitions of tall items.
w instead of W h .
When item rotations are allowed, part-wide(Wp ) gives us Hp,r p,r

F.6.3 Rounding Algorithm

Based on part-big and part-wide, we define an algorithm iter-fine-parts (Algorithm 2) that

returns a set of fine partitionings. We then use iter-fine-parts to design the algorithm round
(Algorithm 3).
Assume that in an output (I, e D) of round(I, ε), the knowledge of the associated fine parti-
e
tioning is implicitly present in I.

42
Algorithm 2 iter-fine-parts(I): I is a set of weight-rounded items. Returns a set of pairs
b where D is a subset of items to discard and Pb is a fine partitioning of I − D.
of the form (D, P),
1: outputs = {}
2: {Bp : ∀p} ∪ {Wp : ∀p} ∪ {Hp : ∀p} ∪ (small and dense partitions) = coarse-partition(I)
nY
bwc nY
wwc nY
wwc
3: iters = part-big(Bp ) × part-wide(Wp ) × part-wide(Hp )
p=1 p=1 p=1
4: for L ∈ iters do // L is a list of pairs
5: Pb = (small and dense partitions)
6: D = {}
7: for (Dj , Pbj ) ∈ L do
8: D = D ∪ Dj
9: Include partitions of Pbj into P.
b
10: end for
11: outputs. add((D, P)) b
12: end for
13: return outputs

e D ′ ), where D ′ is a subset of
Algorithm 3 round(I, ε): Returns a set of pairs of the form (I,
items to discard and Ie is a rounding of I − D ′ .
1: outputs ={} 
1 2ε
2: δ0 := min ,
4d + 1 3
3: (Imed , ε2 , ε1 ) = remove-medium(I, ε, f, δ0 ) // f will be described later
4: // Assume ε and ε1 are passed as parameters to all subroutines and transformations.
5: Let Ib be the weight-rounding (Transformation 21) of I − Imed .
6: for (D, P)b ∈ iter-fine-parts(I) b do
7: Let Ie be the instance obtained by applying Transformation 25 to Ib − D based on the
fine partitioning P. b
8: outputs. add((I, e D ∪ Imed )).
9: end for
10: return outputs

Lemma 53 (Polynomial-time). The total number of outputs of round(I) is O(nγ ), where there
are n items in I and
 
8(d + 1) 4 d+1
γ := nbwc + 2nwwc + .
εε31 ε21 εε1

The time for each output is at most O(n2 /εε1 ).

Proof. Follows from Claims 48 and 52.

e D ′ ) be an output of round(I, ε). Then
Lemma 54 (Low discard). Let (I,
 
′ 6ε2 nwwc d + 1 4 4
span(D ) ≤ ε span(I) + + 2−
ε21 εε1 ε1 ε1
ε2 nwwc
≤ ε span(I) + 6(d + 5) .
ε41

Proof. Let D ′ = D ∪ Imed . By Lemma 19, span(Imed ) ≤ ε span(I). Let D1 be the wide items in
D and D2 be the tall items in D. Since all items in D come from part-wide, D only contains

43
non-dense items and D = D1 ∪ D2 . Let
 
d+1 4 4
λ := nwwc (3ε2 ) + 2− .
εε1 ε1 ε1

By Claim 50, h(D1 ) ≤ λ and w(D2 ) ≤ λ.

X X   X h(i)
h(i) λ
span(D1 ) = max(a(i), vmax (i)) ≤ max h(i), 2 ≤ ≤ 2.
ε1 ε21 ε1
i∈D1 i∈D1 i∈D1

Similarly, span(D2 ) ≤ λ/ε21 .

Lemma 55 (Homogeneity). Let (I, e D) be an output of round(I, ε). Then the number of types
e
of items in I is at most a constant:
 
8(d + 1)nbwc d+1 4
+ 2nwwc + 2 + nswc + 2(nlwc + nhwc ).
εε31 εε1 ε1

Proof. After applying Transformation 25 to Ib − D, all non-dense items in each fine partition
have:

• the same weight class.

• the same width, if the fine partition contains only wide or big items.
• the same height, if the fine partition contains only tall or big items.

From the definition of fine partitioning, the number of different partitions of non-dense items is
at most
 
8nbwc 1 4
+ 2nwwc + + nswc .
ε21 δlg δlg ε21

In each division, there are nhwc distinct heavy dense items and nlwc weight classes in light dense
items by Lemmas 40 and 42.

Table 3: Upper bound on the number of different types of items

no. of types
w
Division-1 big items (B∗,∗,∗ ) 4(d + 1)nbwc /εε31
h
Division-2 big items (B∗,∗,∗ ) 4(d + 1)nbwc /εε31
w
Division-1 wide non-dense items (W∗,∗ ) 4nwwc /ε21
h
Division-2 wide non-dense items (W∗,∗ ) (d + 1)nwwc /εε1
w
Division-1 tall non-dense items (H∗,∗ ) (d + 1)nwwc /εε1
h
Division-2 tall non-dense items (H∗,∗ ) 4nwwc /ε21
Small non-dense items (S∗ ) nswc
h,1
Division-1 heavy dense items (D ) nhwc
Division-2 heavy dense items (D h,2 ) nhwc
l,1
Division-1 light dense items (D ) nlwc
l,2
Division-2 light dense items (D ) nlwc

Lemma 56. Let P be a balanced fine partitioning of a slicing of I. Then there is some output
b of iter-fine-parts(I) (Algorithm 2) such that Pb is a fine partitioning of I − D and
(D, P)
after Transformation 25, each partition in Pb is a predecessor of the corresponding partition in
P.

44
Proof. Follows from Claims 49 and 51

Theorem 57. There e D ∪ Imed ) of round(I, ε) such that Ie can be fractionally

 is an output
 (I,
2ε
packed into at most 1 + 1−ε (a opt(I)+b)+2 semi-structured (5ε/8)-slacked bins. Here values
of a and b are as per Table 2.
 
2ε
Proof. Let m := 1 + 1−ε (a opt(I) + b) + 2. Lemma 47 guarantees the existence of a balanced
fine partitioning P of a slicing of Ib such that after applying Transformation 25, there is a
(5ε/8)-slacked fractional packing of Ib into m bins that is semi-structured relative to P.
By Lemma 56, we get that there is a fine partitioning Pb of Ib − D such that after applying
Transformation 25, each partition of Pb is a predecessor of the corresponding partition of P.
Therefore, we can pack each item in Ie into the place of some items in the packing of Ib − D.
Therefore, there is a (5ε/8)-slacked fractional packing of Ie into at most m bins that is semi-
b
structured relative to P.

F.7 Existence of Compartmental Packing

Definition 29 (Compartmental packing). Consider a semi-structured packing of items I into
m bins, of which m1 bins are division-1 bins and m − m1 are division-2 bins.
A compartment is defined to be a rectangular region in a bin such that every item either
lies completely inside the region or completely outside the region. Furthermore, a compartment
doesn’t contain big items, and a compartment doesn’t contain both wide and tall items.
′
In a division-1 bin, a compartment is called a dense compartment iff it is the region S (R )
′
and it contains a dense item (recall that S (R ) := [1 − ε1 /2, 1] × [0, 1]). In a division-1 bin, a
compartment is called a sparse compartment iff it satisfies all of these properties:

• The compartment doesn’t contain dense items.

• The compartment contains at least 1 wide item or 1 tall item. If it contains wide items, it
is called a wide compartment, and if it contains tall items, it is called a tall compartment.
• The x-coordinate of the left edge of the compartment is a multiple of ε21 /4.
• The compartment’s width is a multiple of ε21 /4, and if the compartment is tall, its width
is exactly ε21 /4.
• The compartment’s height is rounded, i.e., if the compartment is wide, its height is a
multiple of a constant εcont := εε51 /12 (note that ε−1
cont ∈ Z), and if the compartment is tall,
its height is a sum of the heights of at most 1/ε1 − 1 of the items inside the compartment.

A division-1 bin is said to be compartmental iff we can create non-overlapping dense and
sparse compartments in the bin such that all wide items, tall items and dense items are packed
into compartments.
We can analogously define compartmental packing for division-2 bins by swapping the coor-
dinate axes. A semi-structured bin packing of items is called compartmental if each bin in the
packing is compartmental.

Lemma 58. Let there be a rectangular bin B := [0, 1]2 . Let there be a set I of rectangles packed
inside the bin. Then there is a polynomial-time algorithm which can decompose the empty space
in the bin (B − I) into at most 3|I| + 1 rectangles by either making horizontal cuts only or
making vertical cuts only.

Proof. Extend the top and bottom edges of each rectangle leftwards and rightwards till they
hit another rectangle or the bin boundary. This partitions the empty space into rectangles R.

45
 For each rectangle i ∈ I, the top edge of i is the bottom edge of a rectangle in R, the bottom
edge of i is the bottom edge of two rectangles in R. Apart from possibly the rectangle in R
whose bottom edge is at the bottom of the bin, the bottom edge of every rectangle in R is either
the bottom or top edge of a rectangle in I. Therefore, |R| ≤ 3|I| + 1.
If instead of the top and bottom edges, we extended left and right edges, we would get the
same result, except that the cuts would be vertical.

Lemma 59. If there exists a semi-structured µ-slacked packing of items I into m bins, then
there exists a compartmental µ-slacked fractional packing of I into (1 + 2ε/(1 − µ)) m + 2 bins.

Proof. Consider a division-1 bin. By Property 11b, we get that all dense items (if any) lie in
dense compartments. Next, using the method of Section 3.2.3 in [39] (Rounding the Other Side
> Containers for the wide and long rectangles), we can slice items without moving them and
create non-overlapping compartments in the bin such that all tall and wide items are packed into
compartments. Their method works by first constructing tall compartments and then using the
algorithm of Lemma 58 to partition the space outside tall compartments and big items into wide
compartments. The resulting packing is compartmental, except that compartments’ heights are
not rounded. We will now show how to round the heights of compartments.
Let there be nt tall compartments in the bin and nbig big items in the bin. Define
   
4 1 4 12 1 12
ntcont := 2 −1 ≤ 3 nwcont := 2 −1 +1≤ 3
ε1 ε1 ε1 ε1 ε1 ε1

In the bin, there are 4/ε21 slots of width ε21 /4 and height 1. Consider one such slot. Let there
be k big items that intersect that slot (k can be 0). The height of each big item and each
sparse tall compartment is more than ε1 . Therefore, the number of tall sparse compartments
in that slot is at most 1/ε1 − 1 − k. Each big item spans at least 4/ε1 + 1 slots, and reduces
by 1 the number of tall compartments in the slots it spans. Hence, the number of tall sparse
compartments is at most
     
4 1 4 4 1
nt ≤ 2 − 1 − nbig +1 ≤ 2 − 1 − nbig = ntcont − nbig .
ε1 ε1 ε1 ε1 ε1

By Lemma 58, the number of wide compartments is at most 3(nt + nbig ) + 1 ≤ nwcont .
Since small items can be sliced in both dimensions, we can treat them like a liquid. For each
tall sparse compartment C in the bin, let the tall items in C sink down in this liquid. Then
shift down the top edge of C to the top edge of the topmost tall item in C (so some small items
will no longer be inside C). Then the height of C will be the sum of the heights of at most
1/ε1 − 1 tall items inside C (since tall items have height > ε1 and C has height at most 1).
For each wide compartment C in the bin, unpack a horizontal slice of height h(C) mod εcont
from C (this may require slicing items) and move down the top edge of C by h(C) mod εcont .
This rounds down h(C) to a multiple of εcont .
Apply the above transformation to all division-1 bins and an analogous transformation to
all division-2 bins. This gives us a µ-slacked compartmental packing into m bins. However, we
unpacked some items from wide containers in division-1 bins and tall containers in division-2
bins. We need to repack these items.
Let there be m1 division-1 bins. We removed a slice of height less than εcont from each wide
compartment in division-1 bins. Let S be the set of all such slices from division-1 bins. There
are at most nwcont wide compartments, so h(S) ≤ εcont nwcont m1 . For each slice i ∈ S, define
  
′ vmax (i)
span (i) := max h(i), min ,1 .
1−µ

46
For each slice i ∈ S,
   
′ vmax (i) h(i) h(i)
span (i) ≤ max h(i), ≤ max h(i), 2 ≤ .
1−µ ε1 (1 − µ) ε21 (1
− µ)

Therefore,
X h(S) εcont nwcont
span′ (i) ≤ ≤ 2 m1 .
ε21 (1
− µ) ε1 (1 − µ)
i∈S

Interpret each slice i ∈ S as a 1D item of size span′ (i) and pack the slices one-over-the-other
touching
P the left edge of bins using Next-Fit. By Lemma 43, we can pack them all into 1 +
2 i∈S span′ (i) bins that are µ-slacked. Since εcont = εε51 /12 ≤ εε21 /nwcont , the number of bins
used to pack S is at most
2εcont nwcont 2ε
2 m1 + 1 ≤ m1 + 1.
(1 − µ)ε1 1−µ

These bins are division-1 compartmental; they have just one wide compartment of width 1 and
height 1.
2ε
Similarly, we can pack unpacked items from division-2 bins into at most 1−µ (m − m1 ) + 1
division-2 compartmental µ-slacked bins.

Theorem 60. There is an output (I, e D) of round(I, ε) such that Ie has a compartmental (5ε/8)-
slacked fractional packing into at most (1 + 2ε/(1 − ε))2 (a opt(I) + b) + 4/(1 − ε) bins. Here a
and b are as per Table 2.

Proof. By Theorem 57, there is an output (I,e D) of round(I, ε) such that Ie can be packed into
m := (1 + 2ε/(1 − ε)) (a opt(I) + b) + 2 semi-structured (5ε/8)-slacked bins.
By Lemma 59, the number of compartmental (5ε/8)-slacked bins needed to fractionally pack
e
I is at most (1 + 2ε/(1 − ε)) m + 2 ≤ (1 + 2ε/(1 − ε))2 (a opt(I) + b) + 4/(1 − ε).

Table 4: Upper bound on the number of distinct widths and heights for compartments of
different types

no. of widths no. of heights

4 12
Division-1 wide compartments
ε21 εε51
 1/ε1 −1
(d + 1)nwwc
Division-1 tall compartments 1 +1
εε1
 1/ε1 −1
(d + 1)nwwc
Division-2 wide compartments +1 1
εε1
12 4
Division-2 tall compartments
εε51 ε21

Since division-1 tall items have (d + 1)nwwc /εε1 possible heights, the number of possible
heights of division-1 tall sparse compartments is ((d + 1)nwwc /εε1 + 1)1/ε1 −1 . This is a huge
number of possible heights, and it is possible to reduce it by partitioning tall compartments
into weight classes and using linear grouping. We will not perform this improvement here.

47
F.8 Packing Algorithm
Let I be a subset of the rounded items. Formally, let (Ie′ , D) ∈ round(I ′ , ε) and I ⊆ Ie′ .
We will first present a polynomial-time algorithm fpack(I, m) that takes as input I and an
integer m and either outputs a fractional packing of I into m compartmental µ-slacked bins
(where µ ≤ ε) or claims that fractionally packing I into m compartmental µ-slacked bins is
impossible.
We can use fpack(I, m) to find the optimal compartmental µ-slacked fractional packing of I
by using binary search on m. With slight abuse of notation, let fpack(I) denote this algorithm.
Then, we will present an algorithm that finds a µ-slacked (non-fractional) packing of I by
using fpack(I) as a subroutine. Note that we’re interested in getting a non-fractional µ-slacked
packing of I, but that packing need not be compartmental.

F.8.1 Guessing Bin Configurations

A µ-slacked bin J can have one of 4 possible slack types:

1. Normal: ∀k ∈ [d], vk (J) ≤ 1 − µ.

2. Big single: |J| = 1 and J contains a big item and ∀k ∈ [d], vk (J) ∈ (1 − µ, 1].

3. Dense single: |J| = 1 and J contains a dense item and ∀k ∈ [d], vk (J) ∈ (1 − µ, 1].

4. Dense double: |J| = 2 and J contains two dense items and ∀k ∈ [d], vk (J) ∈ (1 − µ, 1] and
∀i ∈ J, vmax (i) ≤ 1/2.

Note that these slack types are disjoint, i.e., a bin cannot have more than one slack types.
A configuration of a bin is defined to be all of this information: (i) The division type, (ii)
The slack type, (iii) Whether the bin has a dense compartment, (iv) A packing of big items,
heavy items and compartments into the bin.
We will now enumerate all possible configurations that a bin can have.
For a division-1 bin, there are 4(d + 1)nbwc /εε31 different types of big items, nhwc different
types of heavy items, 48/εε71 different types of wide compartments and ((d+1)nwwc /εε1 +1)1/ε1 −1
different types of tall compartments. A bin can pack less than 1/ε21 big items, less than 1/ε1
heavy items at most nwcont wide compartments and at most ntcont tall compartments. Therefore,
by iterating over
 1/ε21 −1  nwcont  1/ε1 −1 !ntcont
′ 4(d + 1)nbwc 48 (d + 1)nwwc
nnconfs := +1 +1 +1 +1
εε31 εε71 εε1

values (a large constant), we can guess the set of big items, heavy items and compartments in
a division-1 bin of normal slack type that does not have a dense compartment. For a bin that
has a dense compartment, the number configurations to consider is n′nconfs (nhwc + 1)1/ε1 −1 .
For a bin of big-single slack type, there are at most 4(d + 1)nbwc /εε31 configurations. For a
bin of dense-single slack type, there are at most nhwc configurations. For a bin of dense-double
slack type, there are at most n2hwc configurations. Double the number of configurations to also
account for division-2 items. Therefore, the total number of configurations is at most
   4(d + 1)n 
′ 1/ε1 −1 bwc 2
nnconfs := 2 nnconfs 1 + (nhwc + 1) + + nhwc + nhwc .
εε31

There can be at most nwcont + ntcont items and compartments in a bin (see the proof of
Lemma 59). Since the x-coordinate of these items and compartments is a multiple of ε21 /4,

48
we can use brute-force to check if they can be packed into  a bin. For each item, guess its x-
2

nwcont +ntcont 
coordinate and its ‘layer’ number. This will take time O 4(nwcont + ntcont )/ε1 .


For m bins, we can have at most m+n nconfs −1
nnconfs −1 ∈ O(mnnconfs −1 ) possible combinations of
configurations. Now for each combination, we will check if the remaining items can fit into the
bins.

F.8.2 Fractionally Packing Wide, Tall, Small and Light items

We will use a linear program to fractionally pack wide, tall, small and light items. Note that
bins of non-normal slack type can only have big and heavy items, which have already been
packed, so we won’t consider them any further.
Definition 30 (Length and Breadth). For an item i, let the length ℓ(i) be the longer geometric
dimension and the breadth b(i) be the shorter geometric dimension (so for a wide item i, ℓ(i) :=
w(i) and b(i) := h(i), and for a tall item i, ℓ(i) := h(i) and b(i) := w(i)). Similarly define ℓ and
b for wide and tall compartments.

In any packing of items in a wide compartment, move a line horizontally upwards, as if

scanning the compartment. The line, at each point, will intersect some wide items. The set
of such wide items is called a 1D configuration. Similarly define 1D configuration for items in
tall compartments. Any fractional packing of items inside a compartment can be described by
mentioning the breadths of all 1D configurations in the compartment. The number of types of
items is a constant and there can be at most 1/ε1 − 1 items in a 1D configuration. Therefore,
the number of 1D configurations is a constant.

• Let M1 and M2 be the set of division-1 bins and division-2 bins respectively of normal
slack type. Let M := M1 ∪ M2 . Let MD ⊆ M be the set of bins that have a dense
compartment.
• Let the set of wide and tall non-dense item types be L. For t ∈ L, let b(t) be the sum of
breadths of items of type t and each item has length ℓ(t).
• Let Ji be the set of compartments in bin i.
• For compartment j, let Cj be the set of feasible 1D configurations and let b(j) be the
breadth of the compartment.
• Let ℓC be the sum of lengths of items in 1D configuration C.
• Let nt,C be the number of items of type t in 1D configuration C.
• Let αk,C be the weight-to-breadth ratio of 1D configuration C in the kth vector dimension.
• Let βk,p be the weight-to-area ratio of weight class p for small non-dense items.
• Let γk,p := vk (i)/vmax (i) for a light dense item i in weight class p.
• Let Bi be the set of big items in bin i.
• Let Hi be the set of heavy items in bin i.
• Let Di be 1 for bin i if it contains a dense compartment and 0 otherwise.

We will fractionally pack items using a linear program that only has constraints and has no
objective function. We call it the fractional packing feasibility program FP. It has variables x,
y and z, where

• xj,C is the breadth of 1D configuration C in compartment j.

• yi,p is the area of small non-dense items of weight class p in bin i.
• zi,p is the vmax of light dense items of weight class p in bin i. When i 6∈ MD , zi,p is the
constant 0 instead of being a variable.

Feasibility program FP:

49
 X
xj,C = b(j) ∀i ∈ M, ∀j ∈ Ji
C∈Cj
(compartment breadth constraint)

X X n
X swc
ε1
ℓC xj,C + yi,p ≤ 1 − Di − a(Bi )
p=1
2
j∈Ji C∈Cj
∀i ∈ M
(bin area constraint)

X X nX
wwc n
X lwc

αk,C xj,C + βk,p yi,p + γk,pzi,p ≤ 1 − µ − vk (Bi ) − vk (Hi )

j∈Ji C∈Cj p=1 p=1
∀i ∈ M, ∀k ∈ [d]
(bin weight constraint)
XX X
nt,C xj,C = b(t) ∀t ∈ L
i∈M j∈Ji C∈Cj
C∋t
(conservation of wide and tall items)
X
yi,p = a(Sp ) ∀p ∈ [nswc ]
i∈M
(conservation of small items)
X
zi,p = vmax (Dpl,w ) ∀p ∈ [nlwc ]
i∈M1
(conservation of division-1 light items)
X
zi,p = vmax (Dpl,h ) ∀p ∈ [nlwc ]
i∈M2
(conservation of division-2 light items)

xj,C ≥ 0 ∀i ∈ M, ∀j ∈ Ji , ∀C ∈ Cj
yi,p ≥ 0 ∀i ∈ M, ∀p ∈ [nswc ]
zi,p ≥ 0 ∀i ∈ MD , ∀p ∈ [nlwc ]
(non-negativity constraints)

The number of constraints in FP (other than the non-negativity constraints) is at most

 
4 d+1
nc := m(nwcont + ntcont + d + 1) + 2nwwc + + nswc + 2nlwc
ε21 εε1
   
16 4 d+1
≤ 3 + d m + 2nwwc 2 + +1 (2nlwc ≤ nwwc and nswc ≤ nwwc )
ε1 ε1 εε1
 
16 nwwc
≤ 3 + d m + 2(d + 6) 2 .
ε1 ε1

The number of variables and constraints in FP are linear in m. Therefore, FP can be solved
in time polynomial in m. Furthermore, if FP is feasible, we can obtain an extreme-point solution
to FP.
Therefore, fpack(I, m) guesses all combinations of configurations of m bins and for each such
combination of configurations solves the feasibility program to check if the remaining items can
be packed into the bins according to the bin configurations. Furthermore, fpack(I, m) runs

50
in time polynomial in m. fpack(I) makes at most O(log n) calls to fpack(I, m) with m ≤ n.
Therefore, fpack(I) runs time polynomial in n.

F.8.3 Getting Containers from a Fractional Packing Solution

Suppose fpack(I) outputs a fractional packing that uses m bins. In each compartment j, we
create a slot of breadth xj,C for each 1D configuration C. Since we’re given an extreme-point
solution to FP, the number of slots is at most the number of constraints nc by rank lemma. In
each slot, we create nt,C containers of type t ∈ L having length ℓ(t) and breadth xj,C .
Now we (non-fractionally) pack a large subset of wide and tall items into containers and we
pack a large subset of small non-dense and light dense items outside containers. In each wide
container, items will be stacked one-over-the-other. In each tall container, items will be stacked
side-by-side. We pack the remaining unpacked items into a small number of new bins. This will
give us a non-fractional packing that uses close to m bins.

F.8.4 Packing Light Dense Items

For light dense items, for each bin i and each weight class p ∈ [nlwc ], keep adding items of
the same division as the bin and from weight class p to the bin till the total vmax of the items
exceeds zi,p . Then discard the last item that was added.
As per the conservation constraints for light dense items, all items will either be packed or
discarded. The vmax of items from weight class p that are packed into bin i is at most zi,p .
The number of discarded items is at most the number of z-variables in FP, which is at most
mnlwc . Let D be the set of discarded items. Then span(D) = vmax (D) ≤ (ε2 nlwc )m. We choose
ε2 ≤ ε/nlwc . Since ε2 ≤ ε21 (1 − ε), each item’s weight is at most 1 − ε. Therefore, we can use
Next-Fit to pack D into 2 span(D)/(1 − µ) + 2 ≤ 2εm/(1 − µ) + 2 number of µ-slacked bins
(by scaling up each item’s weight by 1/(1 − µ) before packing and scaling it back down after
packing), where tall and small dense items are packed separately from wide dense items.
The time taken to pack these items is O(|D∗l,∗ |).

F.8.5 Packing Wide and Tall Non-Dense Items

For each item type t, iteratively pack items of type t into a container of type t till the total
breadth of items in the container exceeds xj,C . Then discard the last item and move to a new
container and repeat. As per the conservation constraints for wide and tall items, all items will
either be packed or discarded.
Treat the items discarded from each slot C as a single (composite) item of breadth ε2 , length
ℓC and weight ε2 /ε21 in each dimension. We will pack these composite items into bins, where
wide and tall items are packed separately.
Let D be the set of all such discarded items. Then |D| ≤ nc . For a composite item i, let
  
′ vmax (i)
span (i) := max b(i), min ,1 .
1−µ

Treat each composite item as a 1D item of size span′ (i). Then by Lemma 43, we can use Next-
Fit to pack these items into 2 span′ (D) + 2 µ-slacked bins, where wide and tall items are packed
separately.
   
′ vmax (i) ε2 ε2
span (i) ≤ max b(i), ≤ max ε2 , 2 ≤ 2 .
1−µ ε1 (1 − µ) ε1 (1 − µ)

51
Therefore, the number of bins needed is

ε2 2ε2 (16 + dε31 ) 4(d + 6) ε2 nwwc

2 span′ (D) + 2 ≤ 2 2 n c + 2 ≤ 5 m+ + 2.
ε1 (1 − µ) ε1 (1 − µ) 1−µ ε41

Therefore, we choose ε2 ≤ εε51 /(16 + dε31 ) so that the number of new bins needed is at most

2ε 4(d + 6) ε2 nwwc
m+2+ .
1−µ 1−µ ε41

The time taken to pack these items is O(|L|).

F.8.6 Packing Small Non-Dense Items

In each bin, there are at most nwcont + ntcont compartments and big items (see the proof of
Lemma 59). By Lemma 58, the free space outside compartments can be partitioned into
   
16 1 48
3(nwcont + ntcont ) + 1 ≤ 3 2 −1 +1 +1≤ 3
ε1 ε1 ε1

rectangular regions. Suppose there are pi slots in bin i for which xj,C > 0. The sum of pi over
all bins is equal to nc , the number of constraints in FP. Each slot may give us a free rectangular
region in the compartment. Therefore, the free space in bin i can be partitioned into pi + 48/ε31
rectangular regions. Let Ri denote the set of these free rectangular regions.
Let M be the set of bins of normal slack type. Let m := |M |. Then
X  
48 64
|Ri | ≤ nc + 3 m ≤ + d m.
ε1 ε31
i∈M

This observation forms the basis of our algorithm pack-small (Algorithm 4) for packing small
non-dense items.

Lemma 61. Algorithm pack-small(I, M ) doesn’t fail at line 21.

Proof. Since all items have area at most ε22 ,

a(T ) < a(r) − 2ε2 + ε22 ≤ a(r) − (w(r) + h(r))ε2 + ε22 = (w(r) − ε2 )(h(r) − ε2 ).

Therefore, by Lemma 10, we get that T can be packed into r.

Lemma 62. In pack-small(I, M ), every small non-dense item is either packed or discarded.

Proof by contradiction. Assume ∃p ∈ [nswc ] such that there are items in Sp that are neither
packed nor discarded. Therefore, for each bin i, at Line 12, a(Si,p ) ≥ yi,p . Therefore, the total
area of all items from Sp that are either packed or discarded is at least
X
yi,p = a(Sp ) (by conservation constraint in FP)
i∈M

which means that all items have been packed or discarded, which is a contradiction.
 
Lemma 63. Let D1 ∪ D2 = pack-small(I, M ). Then a(D1 ∪ D2 ) ≤ ε2 nswc + 128 ε 3 + 2d m.
1

52
Algorithm 4 pack-small(I, M, y): Here I is a set of items and M is the fractional packing
output by fpack(I). (x, y, z) is a feasible solution to FP output by fpack(I).
1: Let Sp be the pth coarse partition of small non-dense items in I.
2: D1 = D2 = {} // sets of items to discard
3: for each bin i ∈ M of normal slack type do
4: Let Ri be the set of free rectangular regions in bin i.
5: // Select a set of items to pack
6: Sb = {}
7: for p ∈ [nswc ] do
8: Si,p = {}
9: while a(Si,p ) < yi,p and |Sp | > 0 do
10: Move an item from Sp to Si,p .
11: end while
12: if a(Si,p ) > yi,p then
13: Move the last item in Si,p to D1 .
14: end if
15: Sb = Sb ∪ Si,p
16: end for
17: // Pack those items into Ri
18: while |Ri | > 0 and |S| b > 0 do
19: Remove a rectangle r from Ri .
20: Let T be the smallest prefix of Sb such that a(T ) ≥ a(r) − 2ε2 or T = Sb
21: Pack T into r using NFDH. // We will prove that this is possible
22: Sb -= T
23: end while
24: D2 = D2 ∪ Sb
25: end for
26: return D1 ∪ D2 // discarded items

Proof. During pack-small(I, M ), for each bin, a(D1 ) increases by at most ε2 nswc . Therefore,
a(D1 ) ≤ ε2 nswcm.
We know that a(S)b ≤ Pnswc yi,p ≤ a(Ri ). The first inequality follows from the way we chose
p=1
b The second inequality follows from the area constraint in FP.
S.
Case 1: We used up all items in Sb during bin i:
We didn’t discard any items during bin i.
Case 2: We used up all rectangles in Ri during bin i:
Then the used area is at least a(Ri ) − 2ε2 |Ri |. Therefore, the items discarded during bin i have
b − a(Ri ) + 2ε2 |Ri | ≤ 2ε2 |Ri |. Therefore,
area at most a(S)
X  
64
a(D2 ) ≤ 2ε2 |Ri | ≤ 2ε2 + d m.
ε31
i∈M

Lemma 64. Let D := pack-small(I, M ). Then we can pack D into 2εm/(1 − µ) + 1 number
of µ-slacked bins, where µ ≤ ε.

Proof. Since ε22 ≤ (1 − ε)ε21 , we get that ∀i ∈ D, vmax (i) ≤ 1 − ε ≤ 1 − µ. Let span′ (i) =
a(i)/ε21 (1 − µ). Then by interpreting each i ∈ D as a 1D item of size span′ (i), we can pack them
into 2 span′ (D) + 1 bins using Next-Fit. In each bin J, vmax (J) ≤ a(J)/ε21 = (1 − µ) span′ (J) ≤
1 − µ. Also, a(J) ≤ ε21 (1 − µ) span′ (J) ≤ (1 − ε2 )2 . Therefore, the bin is µ-slacked and by
Lemma 10, we can pack items J in the bin using NFDH.

53


We choose ε2 ≤ εε21 / nswc + 128/ε31 + 2d . Therefore, the number of bins needed is at most

2a(D) 2ε
2 span′ (D) + 1 ≤ +1≤ m + 1.
ε21 (1
− µ) 1−µ

The time taken to pack small items is O(nS log nS ), where nS is the number of small items,
because we need to sort items by height for NFDH.

F.8.7 The Algorithm and its Approximation Factor

We give an algorithm ipackµ (Algorithm 5) for packing a subset I of rounded items.

Algorithm 5 ipackµ (I): Computes a non-fractional µ-slacked packing of I. Here µ ≤ ε and

I ⊆ Ie′ and (D, Ie′ ) ∈ round(I ′ ) for some set I ′ of items.
1: Let (J, x, y, z) := fpackµ (I). Here J is a fractional packing of I into m bins and (x, y, z) is
a feasible solution to the feasibility program FP.
2: Create containers inside compartments in J using x as per Appendix F.8.3.
3: Pack light dense items into dense compartments using z as per Appendix F.8.4.
4: Pack wide and tall non-dense items into containers as per Appendix F.8.5.
5: pack-small(I, J, y) // Pack small non-dense items outside containers.

Theorem 65. Let (Ie′ , D) ∈ round(I ′ , ε) and I ⊆ Ie′ . Let there be m bins in the optimal µ-
slacked compartmental fractional packing of I, where µ ≤ ε. Then ipackµ (I) runs in polynomial
time and outputs a µ-slacked packing of I into
 
6ε 4(d + 6) ε2 nwwc
1+ m+5+
1−µ 1−µ ε41

bins, where each bin satisfies either Property 11b or Property 12b.

Proof. fpack(I) finds the optimal µ-slacked compartmental fractional packing of I in polynomial
time. Given the output of fpack(I), ipack can, in O(n log n) time, compute a packing of I into
(1 + 6ε/(1 − µ)) m + 5 + 4(d + 6)ε2 nwwc /ε41 (1 − µ) number of µ-slacked bins.
Each bin satisfies either Property 11b or Property 12b. This is because the m bins output
by the fractional packing are compartmental, and the extra bins either contain only dense tall
and small items or only dense wide items or only non-dense items.

−1
We choose ε2 := max nlwc /ε, (16 + d3 )/εε51 , (128 + ε31 (nswc + 2d))/εε51 . Hence, ε−1
2 ∈
−(2d+2)
O(ε−5 −d
1 + ε ε1 ). So, the parameter f in remove-medium(I, ε, f, δ0 ) is
&
d !'−1
nlwc 16 + d3 128 + x3 ( 8/x2 ε + 2d)
f (x) = max , , .
ε εx5 εx5

e D) ∈ round(I, ε), if we pack

Theorem 66. Let I be a (2, d) bin packing instance. For some (I,
e
D using simple-pack and pack I using ipack, we get a packing of I into at most

4(10d + 51) ε2 nwwc

((1 + 17ε)a + 6ε(d + 1)) opt(I) + O(1) +
1−ε ε41

bins. Here a is the constant defined in Table 2 in Appendix F.3.

54
Proof. By Theorem 60, ∃(I, e D) ∈ round(I, ε) such that Ie has a compartmental (5ε/8)-slacked
fractional packing into at most m := (1 + 2ε/(1 − ε))2 a opt(I) + O(1) bins.
By Theorem 4 and Lemmas 2 and 54, we get
 
ε2 nwwc
| simple-pack(D)| ≤ 6 span(D) + 3 ≤ 6 ε span(I) + 6(d + 5) +3
ε41
 
ε2 nwwc
≤ 6ε(d + 1) opt(I) + 3 + 36(d + 5) .
ε41

e where µ := 5ε/8. Then the bins in J are (5ε/8)-slacked. The number

Let J := ipackµ (I),
of bins in J is at most
 
6ε 4(d + 6) ε2 nwwc
1+ m+5+
1−µ 1−µ ε41
   
2ε 2 6ε 4(d + 6) ε2 nwwc
≤ 1+ 1+ a opt(I) + O(1) +
1−ε 1−ε 1−ε ε41
4(d + 6) ε2 nwwc
≤ (1 + 17ε)a opt(I) + O(1) + . (ε ≤ 1/8)
1−ε ε41

To get a packing of I − D from a packing of I, e we need to revert the transformations done

by round. The only transformation in round where we rounded down instead of rounding up
is Transformation 18. As per Lemma 38, it is possible to undo Transformation 18 because the
bins are (5ε/8)-slacked and each bin satisfies either Property 11b or Property 12b.

By Theorem 66, we get that for every ε′ > 0, there is a (a + ε′ )-asymptotic-approx algorithm
for (2, d) bin packing. We can get a better approximation factor by using the Round-and-Approx
Framework, and we call the resulting algorithm cb-pack.

F.9 Using the Round-and-Approx Framework

To implement cb-pack, we need to show how to implement round, complex-pack and unround,
and we must prove the structural theorem.

1. solve-config-lp(I): Using the algorithm of [32] for (2, d) KS and the LP algorithm of
[40], we get a 2(1 + ε)-approximate solution to configLP(I). Therefore, µ = 2(1 + ε).

2. round: We can use Algorithm 3 as round. By Lemma 53, round runs in polynomial
time. By Lemma 54, round has low discard. By Lemma 55, round partitions items into
a constant number of classes.

3. Structural theorem: Theorem 60. We call a packing structured iff it is compartmental

and (5ε/8)-slacked. Here ρ = a(1 + 2ε/(1 − ε))2 .

4. complex-pack(S):e Use ipack as complex-pack, where µ = 5ε/8. By Theorem 65, α =

µ
1 + 6ε/(1 − ε).

5. unround(Je): Since the output of ipack is (5ε/8)-slacked and each bin satisfies either
Property 11b or Property 12b, we can use Lemma 38 to undo Transformation 18. The
other transformations round up, so they are trivial to undo. Therefore, γ = 1.

The only remaining requirement of the Round-and-Approx framework is proving the bounded
expansion lemma.

55
Lemma 67 (Bounded expansion). Let (I, e D) ∈ round(I, ε). Let K e ⊆ Ie be a fine partition of
e e
I. Let C ⊆ I be a set of items that fit into a bin and let C be the corresponding rounded items.
Then span(Ke ∩ C)
e is upper-bounded by 1/ε1 + 1/4.

Proof. To prove this, it is sufficient to prove that ∀i ∈ I − D, if item i gets rounded to item ı̃,
then span(ı̃)/ span(i) is upper-bounded by 1/ε1 + 1/4.

1. Big items: We will consider division-1 big items. The analysis for division-2 big items is
analogous.

w(ı̃) ≤ w(i) + ε21 /4 ∧ h(ı̃) ≤ 1 (by Transformation 25)

w(ı̃) ε1 h(ı̃) 1
=⇒ ≤1+ ∧ ≤
w(i) 4 h(i) ε1
a(ı̃) a(ı̃) w(ı̃) h(ı̃) 1 1
=⇒ ≤ ≤ ≤ +
span(i) a(i) w(i) h(i) ε1 4

vmax (ı̃) vmax (i) + ε21 ε/8

≤ (by Transformation 17)
span(i) max(a(i), vmax (i))
 
vmax (i) ε ε21 ε
≤ min + ,1 +
ε21 8 8vmax (i)
 
vmax (i) ε ε21
≤ 1 + min ,
ε21 8 vmax (i)
r
ε 3 1 1
≤1+ ≤ ≤ + (ε1 ≤ 2/3)
8 2 ε1 4

2. Non-dense wide items:

a(ı̃) a(ı̃) w(ı̃) 1
≤ = ≤
span(i) a(i) w(i) ε1

vmax (ı̃) vmax (i) + h(i)(ε1 ε/8)

≤ (by Transformation 17)
span(i) max(h(i)ε1 , vmax (i))
 
vmax (i) ε ε ε1 h(i)
≤ min + ,1 +
ε1 h(i) 8 8 vmax (i)
 
vmax (i) ε ε1 h(i)
≤ 1 + min ,
ε1 h(i) 8 vmax (i)
r
ε 3 1
≤1+ ≤ ≤ (ε1 ≤ 2/3)
8 2 ε1

3. Non-dense tall items: Similar to the non-dense wide items case.

4. Non-dense small items: a(ı̃) = a(i).
vmax (ı̃) vmax (i) + a(i)(ε/8)
≤ (by Transformation 17)
span(i) max(a(i), vmax (i))
 
vmax (i) ε ε a(i)
≤ min + ,1 +
a(i) 8 8 vmax (i)
 
vmax (ı̃) ε a(i)
≤ 1 + min ,
a(i) 8 vmax (i)
r
ε 3 1
≤1+ ≤ ≤ (ε1 ≤ 2/3)
8 2 ε1

56
 5. Heavy dense items: (See Transformation 19)

span(ı̃) vmax (ı̃) ε1 ε ε 1

≤ ≤1+ ≤1+ ≤
span(i) vmax (i) 8vmax (i) 8 ε1

6. Light dense items: (See Transformation 20)

span(ı̃) vmax (ı̃) ε 1

≤ ≤1+ ≤
span(i) vmax (i) 8 ε1

The asymptotic approximation factor given by the Round-and-Approx framework is

    a 
αργ
µ 1+ + Θ(1)ε = 2 1 + ln + Θ(1)ε
µ 2

Using Table 2, for d = 1, we get 2.919065+ε′ when item rotations are forbidden and 2.810930+ε′
when item rotations are allowed.

57