1 Introduction
In this paper, we consider the strip packing problem, a wellstudied classical twodimensional packing problem [6, 15, 32]. Here we are given a collection of rectangles, and an infinite vertical strip of width in the two dimensional (2D) plane. We need to find an axisparallel embedding of the rectangles without rotations inside the strip so that no two rectangles overlap (feasible packing). Our goal is to minimize the total height of this packing.
More formally, we are given a parameter and a set of rectangles, each one characterized by a width , , and a height . A packing of is a pair for each , with , meaning that the leftbottom corner of is placed in position and its righttop corner in position . This packing is feasible if the interiors of the rectangles are pairwise disjoint in this embedding (or equivalently rectangles are allowed to overlap on their boundary only). Our goal is to find a feasible packing of minimum height .
Strip packing is a natural generalization of onedimensional bin packing [14] (when all the rectangles have the same height) and makespan minimization [13] (when all the rectangles have the same width). The problem has lots of applications in industrial engineering and computer science, specially in cutting stock, logistics and scheduling [32, 21]. Recently, there have been a lot of applications of strip packing in electricity allocation and peak demand reduction in smartgrids [40, 31, 36].
A simple reduction from the partition problem shows that the problem cannot be approximated within a factor for any in polynomialtime unless P=NP. This reduction relies on exponentially large (in ) rectangle widths.
Let denote the optimal height for the considered strip packing instance , and (resp. ) be the largest height (resp. width) of any rectangle in . Observe that trivially . W.l.o.g. we can assume that . The first nontrivial approximation algorithm for strip packing, with approximation ratio 3, was given by Baker, Coffman and Rivest [6]. The FirstFitDecreasingHeight algorithm (FFDH) by Coffman et al. [15] gives a 2.7 approximation. Sleator [38] gave an algorithm that generates packing of height , hence achieving a 2.5 approximation. Afterwards, Steinberg [39] and Schiermeyer [37] independently improved the approximation ratio to 2. Harren and van Stee [22] first broke the barrier of 2 with their 1.9396 approximation. The present best approximation is due to Harren et al. [21].
Recently algorithms running in pseudopolynomial time (PPT) for this problem have been developed. More specifically, the running time of a PPT algorithm for Strip Packing is , where ^{2}^{2}2For the case without rotations, the polynomial dependence on can indeed be removed with standard techniques.. First, Jansen and Thöle [28] showed a PPT approximation algorithm, and later Nadiradze and Wiese [35] overcame the inapproximability barrier by presenting a PPT approximation algorithm. As strip packing is strongly NPhard [19], it does not admit an exact PPT algorithm.
1.1 Our contribution and techniques
In this paper, we make progress on the PPT approximability of strip packing, by presenting an improved approximation. Our approach refines the technique of Nadiradze and Wiese [35], that modulo several technical details works as follows: let be a proper constant parameter, and define a rectangle to be tall if . They prove that the optimal packing can be structured into a constant number of axisaligned rectangular regions (boxes), that occupy a total height of inside the vertical strip. Some rectangles are not fully contained into one box (they are cut by some box). Among them, tall rectangles remain in their original position. All the other cut rectangles are repacked on top of the boxes: part of them in a horizontal box of size , and the remaining ones in a vertical box of size (that we next imagine as placed on the topleft of the packing under construction).
Some of these boxes contain only relatively high rectangles (including tall ones) of relatively small width. The next step is a rearrangement of the rectangles inside one such vertical box (see Figure 2(a)), say of size : they first slice nontall rectangles into unit width rectangles (this slicing can be finally avoided with standard techniques). Then they shift tall rectangles to the top/bottom of , shifting sliced rectangles consequently (see Figure 2(b)). Now they discard all the (sliced) rectangles completely contained in a central horizontal region of size , and they nicely rearrange the remaining rectangles into a constant number of subboxes (excluding possibly a few more nontall rectangles, that can be placed in the additional vertical box).
These discarded rectangles can be packed into extra boxes of size (see Figure 2(d)). In turn, the latter boxes can be packed into two discarded boxes of size , that we can imagine as placed, one on top of the other, on the topright of the packing. See Figure 0(a) for an illustration of the final packing. This leads to a total height of , which is minimized by choosing .
Our main technical contribution is a repacking lemma that allows one to repack a small fraction of the discarded rectangles of a given box inside the free space left by the corresponding subboxes (while still having many subboxes in total). This is illustrated in Figure 2(e). This way we can pack all the discarded rectangles into a single discarded box of size , where is a small constant depending on , that we can place on the topright of the packing. The vertical box where the remaining rectangles are packed still fits to the topleft of the packing, next to the discarded box. See Figure 0(b) for an illustration. Choosing gives the claimed approximation factor.
We remark that the basic approach by Nadiradze and Wiese strictly requires that at most tall rectangles can be packed one on top of the other in the optimal packing, hence imposing . Thus in some sense this work pushes their approach to its limit.
The algorithm by Nadiradze and Wiese [35] is not directly applicable to the case when
rotations are allowed. In particular, they use a linear program to pack some rectangles. When rotations are allowed, it is unclear how to decide which rectangles are packed by the linear program. We use a combinatorial
containerbased approach to circumvent this limitation, which allows us to pack all the rectangles using dynamic programming. This way we achieve a PPT approximation for strip packing with rotations, breaking the polynomialtime approximation barrier of 3/2 for that variant as well.1.2 Related work
For packing problems, many pathological lower bound instances occur when is small. Thus it is often insightful to consider the asymptotic approximation ratio. Coffman et al. [15] described two leveloriented algorithms, NextFitDecreasingHeight (NFDH) and FirstFitDecreasingHeight (FFDH), that achieve asymptotic approximations of 2 and 1.7, respectively. After a sequence of improvements [20, 5], the seminal work of Kenyon and Rémila [32] provided an asymptotic polynomialtime approximation scheme (APTAS) with an additive term . The latter additive term was subsequently improved to by Jansen and SolisOba [27].
In the variant of strip packing with rotations, we are allowed to rotate the input rectangles by (in other terms, we are free to swap the width and height of an input rectangle). The case with rotations is much less studied in the literature. It seems that most of the techniques that work for the case without rotations can be extended to the case with rotations, however this is not always a trivial task. In particular, it is not hard to achieve a approximation, and the hardness of approximation extends to this case as well [27]. In terms of asymptotic approximation, Miyazawa and Wakabayashi [34] gave an algorithm with asymptotic performance ratio of 1.613. Later, Epstein and van Stee [16] gave a asymptotic approximation. Finally, Jansen and van Stee [29] achieved an APTAS for the case with rotations.
Strip packing has also been well studied for higher dimensions. The present best asymptotic approximation for 3D strip packing is due to Jansen and Prädel [24] who presented a 1.5approximation extending techniques from 2D bin packing.
There are many other related geometric packing problems. For example, in the independent set of rectangles problem we are given a collection of axisparallel rectangles embedded in the plane, and we need to find a maximum cardinality/weight subset of nonoverlapping rectangles [2, 10, 11]. Interesting connections between this problem and the unsplittable flow on a path problem were recently discovered [4, 7, 9]. In the geometric knapsack problem we wish to pack a maximum cardinality/profit subset of the rectangles in a given square knapsack [3, 17, 30]. One can also consider a natural geometric version of bin packing, where the goal is to pack a given set of rectangles in the smallest possible number of square bins [8]. We refer the readers to [12, 33] for surveys on geometric packing problems.
Subsequent Progress: Since the publication of our extended abstract [18], new results have appeared. Adamaszek et al. [1] proved that there is no PPT approximation algorithm for Strip Packing unless . On the other hand, Jansen and Rau [26] independently showed a PPT approximation algorithm with running time for the case without rotations. Very recently, new results have been announced [23, 25] claiming to give a tight approximation algorithm.
1.3 Organization of the paper
First, we discuss some preliminaries and notations in Section 2. Section 3 contains our main technical contribution, the repacking lemma. Then, in Section 4, we discuss a refined structural result leading to a packing into many containers. In Section 5, we describe our algorithm to pack the rectangles and in Section 6 we extend our algorithm to the case with rotations. Finally, in Section 7, we conclude with some observations.
2 Preliminaries and notations
Throughout the present work, we will follow the notation from [35], which will be explained as it is needed.
Recall that denotes the height of the optimal packing for instance . By trying all the pseudopolynomially many possibilities, we can assume that is known to the algorithm. Given a set of rectangles, will denote the total area of rectangles in , i.e., , and (resp. ) denotes the maximum height (resp. width) of rectangles in . Throughout this work, a box of size means an axisaligned rectangular region of width and height .
In order to lighten the notation, we sometimes interpret a rectangle/box as the corresponding region inside the strip according to some given embedding. The latter embedding will not be specified when clear from the context. Similarly, we sometimes describe an embedding of some rectangles inside a box, and then embed the box inside the strip: the embedding of the considered rectangles is shifted consequently in that case.
A vertical (resp. horizontal) container is an axisaligned rectangular region where we implicitly assume that rectangles are packed one next to the other from left to right (resp., bottom to top), i.e., any vertical (resp. horizontal) line intersects only one packed rectangle (see Figure 1(b)). Containerlike packings will turn out to be particularly useful since they naturally induce a (onedimensional) knapsack instance.
2.1 Classification of rectangles
Let , and assume for simplicity that
. We first classify the input rectangles into six groups according to parameters
satisfying and , whose values will be chosen later (see also Figure 1(a)). A rectangle is
Large if and .

Tall if and .

Vertical if and ,

Horizontal if and ,

Small if and ;

Medium in all the remaining cases, i.e., if , or and .
We use , , , , , and to denote large, tall, vertical, horizontal, small, and medium rectangles, respectively. We remark that, differently from [35], we need to allow and due to some additional constraints in our construction (see Section 5).
Notice that according to this classification, every vertical line across the optimal packing intersects at most two tall rectangles. The following lemma allows us to choose and in such a way that and ( and , respectively) differ by a large factor, and medium rectangles have small total area.
Lemma 1.
Given a polynomialtime computable function , with , any constant , and any positive integer , we can compute in polynomial time a set of many positive real numbers upper bounded by , such that there is at least one number so that by choosing , , and .
Proof.
Let . Let , and, for each , define . Let . For each , let and similarly . Observe that is disjoint from (resp. is disjoint from ) for every , and the total area of rectangles in ( respectively) is at most . Thus, there exists a value such that the total area of the elements in is at most . Choosing , , , verifies all the conditions of the lemma. ∎
Function and constant will be chosen later. From now on, assume that and are chosen according to Lemma 1.
2.2 NextFitDecreasingHeight (NFDH)
One of the most common algorithms to pack rectangles into a box of size is NextFitDecreasingHeight (NFDH). In this algorithm, the first step is to sort rectangles nonincreasingly by height, say . Then, the first rectangle is packed in the bottomleft corner, and a shelf is defined of height and width . The next rectangles are put in this shelf, next to each other and touching each other and the bottom of the shelf, until one does not fit, say the th one. At this point we define a new shelf above the first one, with height . This process continues until all the rectangles are packed or the height of the next shelf does not fit inside the box.
This algorithm was studied by Coffman et al. [15] in the context of strip packing, in order to bound the obtained height when all the rectangles are packed into a strip. The result obtained can be summarized in the following lemma.
Lemma 2 (Coffman et al. [15]).
Given a strip packing instance , algorithm NFDH gives a packing of height at most .
One important observation is that each horizontal shelf can be thought of as a vertical container. Another important property of the algorithm is that, if a given set of rectangles needs to be packed into a given bin, and all of them are relatively small compared to the dimensions of the bin, then NFDH is very efficient even in terms of area. This result is summarized in the following lemma.
Lemma 3 (Coffman et al. [15]).
Given a set of rectangles with width at most and height at most , if NFDH is used to pack these rectangles in a bin of width and height , then the total used area in that bin is at least (provided that there are enough rectangles so that NFDH never runs out of them).
2.3 Overview of the algorithm
We next overview some of the basic results in [35] that are required for our result. We define the constant , and w.l.o.g. assume .
Let us forget for a moment small rectangles
. We will pack all the remaining rectangles into a sufficiently small number of boxes embedded into the strip. By standard techniques, as in [35], it is then possible to pack (essentially using NFDH in a proper grid defined by the above boxes) while increasing the total height at most by . See Section 5.1 for more details on how to pack small rectangles.The following lemma from [35] allows one to round the heights and positions of rectangles of large enough height, without increasing much the height of the packing.
Lemma 4.
[35] There exists a feasible packing of height where: (1) the height of each rectangle in is rounded up to the closest integer multiple of and (2) their coordinates are as in the optimal solution and their coordinates are integer multiples of .
We next focus on rounded rectangle heights (i.e., implicitly replace by their rounded version) and on this slightly suboptimal solution of height .
The following lemma helps us to pack rectangles in .
Lemma 5.
If in Lemma 1 is chosen sufficiently large, all the rectangles in can be packed in polynomial time into a box of size and a box of size . Furthermore, there is one such packing using vertical containers in and horizontal containers in .
Proof.
We first pack rectangles in using NFDH into a strip of width . From Lemma 2 we know that the height of the packing is at most . Since and , because of Lemma 1, the resulting packing fits into a box of size . As , the number of shelves used by NFDH is at most , and this also bounds the number of vertical containers needed.
We next pack into a box of size . Recall that . Note that, for each , we have and . By ideally rotating the box and the rectangles by , we can apply the NFDH algorithm. Lemma 2 implies that we can pack all the rectangles if the width of the box is at least . Now observe that
and also, since ,
where the last inequality is true for any . Similarly to the previous case, the number of shelves is at most . Thus all the rectangles can be packed into at most horizontal containers. ∎
We say that a rectangle is cut by a box if both and are nonempty (considering both and as open regions with an implicit embedding on the plane). We say that a rectangle (resp. ) is nicely cut by a box if is cut by and their intersection is a rectangular region of width (resp. height ). Intuitively, this means that an edge of cuts along its longest side (see Figure 1(c)).
Now it remains to pack : The following lemma, taken from [35] modulo minor technical adaptations, describes an almost optimal packing of those rectangles.
Lemma 6.
There is an integer such that, assuming , there is a partition of the region into a set of at most boxes and a packing of the rectangles in such that:

each box has size equal to the size of some (large box), or has height at most (horizontal box), or has width at most (vertical box);

each is contained into a large box of the same size;

each is contained into a horizontal box or is cut by some box. Furthermore, the total area of horizontal cut rectangles is at most ;

each is contained into a vertical box or is nicely cut by some vertical box.
Proof.
We apply Lemma 3.2 in [35], where we set the parameter to . Recall that ; by requiring that , and since rectangles with height in are in , we have that .
Let be the set of horizontal rectangles that are nicely cut by a box. Since rectangles in satisfy , at most of them are nicely cut by a box, and there are at most boxes. Hence, their total area is at most , which is at most , provided that . Since Lemma 3.2 in [35] implies that the area of the cut horizontal rectangles that are not nicely cut is at most , the total area of horizontal cut rectangles is at most . ∎
We denote the sets of vertical, horizontal, and large boxes by and , respectively. Observe that can be guessed in PPT. We next use and to denote tall and vertical cut rectangles in the above lemma, respectively. Let us also define and .
Using standard techniques (see e.g. [35]), we can pack all the rectangles excluding the ones contained in vertical boxes in a convenient manner. This is summarized in the following lemma.
Lemma 7.
Proof.
Note that there are at most rectangles in and at most rectangles in , since at most tall rectangles can be nicely cut by the left (resp. right) side of each box; this is enough to prove points (1) and (3).
Thanks to Lemma 6, the total area of horizontal cut rectangles is at most . By Lemma 2, we can remove them from the packing and pack them in the additional box using NFDH algorithm, proving point (2).
At most rectangles in can be nicely cut by a box; thus, in total there are at most nicely cut vertical rectangles. Since the width of each vertical rectangle is at most , they can be removed from the packing and placed in , piled side by side, as long as , which is equivalent to . This proves point (4). ∎
We will pack all the rectangles (essentially) as in [35], with the exception of where we exploit a refined approach. This is the technical heart of this paper, and it is discussed in the next section.
3 A repacking lemma
We next describe how to pack rectangles in . In order to highlight our contribution, we first describe how the approach by Nadiradze and Wiese [35] works.
It is convenient to assume that all the rectangles in are sliced vertically into subrectangles of width each^{3}^{3}3For technical reasons, slices have width in [35]. For our algorithm, slices of width suffice.. Let be such sliced rectangles. We will show how to pack all the rectangles in into a constant number of subboxes. Using standard techniques it is then possible to pack into the space occupied by plus an additional box of size . See Lemma 11 for more details.
We next focus on a specific vertical box , say of size (see Figure 2(a)). Let be the tall rectangles cut by . Observe that there are at most such rectangles ( on the left/right side of ). The rectangles in are packed as in Lemma 7. Let also and be the tall rectangles and sliced vertical rectangles, respectively, originally packed completely inside .
They show that it is possible to pack into a constant size set of subboxes contained inside , plus an additional box of size . Here denotes the region inside not contained in . In more detail, they start by considering each rectangle . Since by assumption, one of the regions above or below cannot contain another tall rectangle in , say the first case applies (the other one being symmetric). Then is moved up so that its top side overlaps with the top boundary of . The sliced rectangles in that are covered this way are shifted right below (note that there is enough free space by construction). At the end of the process all the rectangles in touch at least one of the top and bottom side of (see Figure 2(b)). Note that no rectangle is discarded up to this point.
Next, we partition the space inside into maximal height unitwidth vertical stripes. We call each such stripe a free rectangle if both its top and bottom side overlap with the top or bottom side of some rectangle in , and otherwise a pseudo rectangle (see Figure 2(c)). We define the th free rectangle to be the free rectangle contained in stripe .
Note that all the free rectangles are contained in a rectangular region of width and height at most contained in the central part of . Let be the set of (sliced vertical) rectangles contained in the free rectangles. Rectangles in can be obviously packed inside . For each corner of the box , we consider the maximal rectangular region that has as a corner and only contains pseudo rectangles whose top/bottom side overlaps with the bottom/top side of a rectangle in ; there are at most such nonempty regions, and for each of them we define a corner subbox, and we call the set of such subboxes (see Figure 2(c)). The final step of the algorithm is to rearrange horizontally the pseudo/tall rectangles so that pseudo/tall rectangles of the same height are grouped together as much as possible (modulo some technical details). The rectangles in are not moved. The subboxes are induced by maximal consecutive subsets of pseudo/tall rectangles of the same height touching the top (resp., bottom) side of (see Figure 2(d)). We crucially remark that, by construction, the height of each subbox (and of ) is a multiple of .
By splitting each discarded box into two halves and , and replicating the packing of boxes inside , it is possible to pack all the discarded boxes into two boxes and , both of size .
A feasible packing of boxes (and hence of the associated rectangles) of height is then obtained as follows. We first pack at the base of the strip, and then on top of it we pack , two additional boxes and (which will be used to repack the horizontal items; see Section 7 for details), and a box (which will be used to pack some of the small items). The latter boxes all have width and height . On the top right of this packing we place and , one on top of the other. Finally, we pack , and on the top left, one next to the other. See Figure 0(a) for an illustration. The height is minimized for , leading to a approximation.
The main technical contribution of this paper is to show how it is possible to repack a subset of into the free space inside not occupied by subboxes, so that the residual sliced rectangles can be packed into a single discarded box of size (repacking lemma). See Figure 2(e). This apparently minor saving is indeed crucial: with the same approach as above all the discarded subboxes can be packed into a single discarded box of size . Therefore, we can pack all the previous boxes as before, and on the top right. Indeed, the total width of , and is at most for a proper choice of the parameters. See Figure 0(b) for an illustration. Altogether the resulting packing has height . This is minimized for , leading to the claimed approximation.
It remains to prove our repacking lemma.
Lemma 8 (Repacking Lemma).
Consider a partition of into unitwidth vertical stripes. There is a subset of at least such stripes so that the corresponding sliced vertical rectangles can be repacked inside in the space not occupied by subboxes.
Proof.
Let denote the height of the th free rectangle, where for notational convenience we introduce a degenerate free rectangle of height whenever the stripe inside does not contain any free rectangle. This way we have precisely free rectangles. We remark that free rectangles are defined before the horizontal rearrangement of tall/pseudo rectangles, and the consequent definition of subboxes.
Recall that subboxes contain tall and pseudo rectangles. Now consider the area in not occupied by subboxes. Note that this area is contained in the central region of height . Partition this area into maximalheight unitwidth vertical stripes as before (newly free rectangles). Let be the height of the th newly free rectangle, where again we let if the stripe does not contain any (positive area) free region. Note that, since tall and pseudo rectangles are only shifted horizontally in the rearrangement, it must be the case that:
Let be the (good) indexes where , and be the bad indexes with . Observe that for each , it is possible to pack the th free rectangle inside the th newly free rectangle, therefore freeing a unitwidth vertical strip inside . Thus it is sufficient to show that .
Observe that, for , : indeed, both and must be multiples of since they correspond to the height of minus the height of one or two tall/pseudo rectangles. On the other hand, for any index , , by the definition of . Altogether
We conclude that . The claim follows since by assumption . ∎
4 A refined structural lemma
The original algorithm in [35] uses standard LPbased techniques, as in [32], to pack the horizontal rectangles. We can avoid that via a refined structural lemma: here boxes and subboxes are further partitioned into vertical (resp., horizontal) containers. Rectangles are then packed into such containers as mentioned earlier: one next to the other from left to right (resp., bottom to top). Containers define a multiple knapsack instance, that can be solved optimally in PPT via dynamic programming. This approach has two main advantages:

It leads to a simpler algorithm.

It can be easily adapted to the case with rotations, as discussed in Section 6.
The goal of this section is to prove the following lemma that summarizes the aforementioned properties.
Lemma 9.
By choosing , there is an integer such that, assuming and , there is a packing of