Bin packing problem
≈ 15 min read
Names in other languages
No names in other languages are held for this entry yet.
Article bodies are English and are not machine-translated. A name in another language is not a translation of the article.
The bin packing problem is an optimization problem, in which items of different sizes must be packed into a finite number of bins or containers, each of a fixed given capacity, in a way that minimizes the number of bins used. The problem has many applications, such as filling up containers, loading trucks with weight capacity constraints, creating file backups in media, splitting a network prefix into multiple subnets, and technology mapping in FPGA semiconductor chip design.
Computationally, the problem is NP-hard, and the corresponding decision problem, deciding if items can fit into a specified number of bins, is NP-complete. Despite its worst-case hardness, optimal solutions to very large instances of the problem can be produced with sophisticated algorithms. In addition, many approximation algorithms exist.
For example, the first fit algorithm provides a fast but often non-optimal solution, involving placing each item into the first bin in which it will fit. It requires Θ(n log n) time, where n is the number of items to be packed.
The algorithm can be made much more effective by first sorting the list of items into decreasing order (sometimes known as the first-fit decreasing algorithm), although this still does not guarantee an optimal solution and for longer lists may increase the running time of the algorithm.…
The bin packing problem is an optimization problem, in which items of different sizes must be packed into a finite number of bins or containers, each of a fixed given capacity, in a way that minimizes the number of bins used. The problem has many applications, such as filling up containers, loading trucks with weight capacity constraints, creating file backups in media, splitting a network prefix into multiple subnets, and technology mapping in FPGA semiconductor chip design.
Computationally, the problem is NP-hard, and the corresponding decision problem, deciding if items can fit into a specified number of bins, is NP-complete. Despite its worst-case hardness, optimal solutions to very large instances of the problem can be produced with sophisticated algorithms. In addition, many approximation algorithms exist.
For example, the first fit algorithm provides a fast but often non-optimal solution, involving placing each item into the first bin in which it will fit. It requires Θ(n log n) time, where n is the number of items to be packed.
The algorithm can be made much more effective by first sorting the list of items into decreasing order (sometimes known as the first-fit decreasing algorithm), although this still does not guarantee an optimal solution and for longer lists may increase the running time of the algorithm. It is known, however, that there always exists at least one ordering of items that allows first-fit to produce an optimal solution.
There are many variations of this problem, such as 2D packing, linear packing, packing by weight, packing by cost, and so on. The bin packing problem can also be seen as a special case of the cutting stock problem.
When the number of bins is restricted to 1 and each item is characterized by both a volume and a value, the problem of maximizing the value of items that can fit in the bin is known as the knapsack problem. A variant of bin packing that occurs in practice is when items can share space when packed into a bin.
Specifically, a set of items could occupy less space when packed together than the sum of their individual sizes. This variant is known as VM packing since when virtual machines (VMs) are packed in a server, their total memory requirement could decrease due to pages shared by the VMs that need only be stored once.
If items can share space in arbitrary ways, the bin packing problem is hard to even approximate. However, if space sharing fits into a hierarchy, as is the case with memory sharing in virtual machines, the bin packing problem can be efficiently approximated. Another variant of bin packing of interest in practice is the so-called online bin packing.
Here the items of different volume are supposed to arrive sequentially, and the decision maker has to decide whether to select and pack the currently observed item, or else to let it pass. Each decision is without recall. In contrast, offline bin packing allows rearranging the items in the hope of achieving a better packing once additional items arrive.
This of course requires additional storage for holding the items to be rearranged.
Formal statement
In Computers and Intractability Garey and Johnson list the bin packing problem under the reference [SR1]. They define its decision variant as follows.
Instance: Finite set I of items, a size s(i) \in \mathbb{Z}^+ for each i \in I , a positive integer bin capacity B , and a positive integer K . Question: Is there a partition of I into disjoint sets I_1,\dots, I_K such that the sum of the sizes of the items in each I_j is B or less? Note that in the literature often an alternate, but not equivalent, notation is used, where B = 1 and s(i) \in \mathbb{Q} \cap (0,1] for each i \in I . Furthermore, research is mostly interested in the optimization variant, which asks for the smallest possible value of K . A solution is optimal if it has minimal K . The K -value for an optimal solution for a set of items I is denoted by \mathrm{OPT}(I) or just \mathrm{OPT} if the set of items is clear from the context.
A possible integer linear programming formulation of the problem is: where y_j = 1 if bin j is used and x_{ij} = 1 if item i is put into bin j . Furthermore, there can be no approximation algorithm with absolute approximation ratio smaller than \tfrac 3 2 unless \mathsf{P} = \mathsf{NP} . This can be proven by a reduction from the partition problem: given an instance of Partition where the sum of all input numbers is 2T , construct an instance of bin-packing in which the bin size is .
If there exists an equal partition of the inputs, then the optimal packing needs 2 bins; therefore, every algorithm with an approximation ratio smaller than must return less than 3 bins, which must be 2 bins. In contrast, if there is no equal partition of the inputs, then the optimal packing needs at least 3 bins.
On the other hand, bin packing is solvable in pseudo-polynomial time for any fixed number of bins , and solvable in polynomial time for any fixed bin capacity . Next Fit (NF) always keeps a single open bin. When the new item does not fit into it, it closes the current bin and opens a new bin.
Its advantage is that it is a bounded-space algorithm since it only needs to keep a single open bin in memory. Its disadvantage is that its asymptotic approximation ratio is 2. In particular, NF(L) \leq 2 \cdot \mathrm{OPT}(L) -1 , and for each N \in \mathbb{N} there exists a list such that \mathrm{OPT}(L) = N and NF(L) = 2 \cdot \mathrm{OPT}(L) -2 .
Its asymptotic approximation ratio can be somewhat improved based on the item sizes: R_{NF}^\infty(\text{size}\leq\alpha) \leq 2 for all \alpha \geq 1/2 and R_{NF}^\infty(\text{size}\leq\alpha) \leq 1/(1-\alpha) for all \alpha \leq 1/2 . For each algorithm that is an AnyFit-algorithm it holds that R_{A}^{\infty}(\text{size}\leq\alpha)\leq R_{NF}^{\infty}(\text{size}\leq\alpha) .
Next-k-Fit (NkF) is a variant of Next-Fit, but instead of keeping only one bin open, the algorithm keeps the last bins open and chooses the first bin in which the item fits. Therefore, it is called a k-bounded space algorithm.
For k\geq 2 the NkF delivers results that are improved compared to the results of NF, however, increasing to constant values larger than improves the algorithm no further in its worst-case behavior. If algorithm is an AlmostAnyFit-algorithm and m = \lfloor 1/\alpha\rfloor \geq 2 then R_{A}^{\infty}(\text{size}\leq\alpha)\leq R_{N2F}^{\infty}(\text{size}\leq\alpha) = 1+1/m . First-Fit (FF) keeps all bins open, in the order in which they were opened.
It attempts to place each new item into the first bin in which it fits. Its approximation ratio is FF(L) \leq \lfloor 1.7\mathrm{OPT}\rfloor , and there is a family of input lists for which FF(L) matches this bound. Best-Fit (BF), too, keeps all bins open, but attempts to place each new item into the bin with the maximum load in which it fits.
Its approximation ratio is identical to that of FF, that is: BF(L) \leq \lfloor 1.7\mathrm{OPT}\rfloor , and there is a family of input lists for which BF(L) matches this bound. Worst-Fit (WF) attempts to place each new item into the bin with the minimum load. It can behave as badly as Next-Fit, and will do so on the worst-case list for that NF(L) = 2 \cdot \mathrm{OPT}(L) -2 .
Furthermore, it holds that R_{WF}^{\infty}(\text{size}\leq \alpha) = R_{NF}^{\infty}(\text{size}\leq \alpha) . Since WF is an AnyFit-algorithm, there exists an AnyFit-algorithm such that R_{AF}^{\infty}(\alpha) = R_{NF}^{\infty}(\alpha) . Almost Worst-Fit (AWF) attempts to place each new item inside the second most empty open bin (or emptiest bin if there are two such bins).
If it does not fit, it tries the most empty one. It has an asymptotic worst-case ratio of \tfrac {17}{10} .
In order to generalize these results, Johnson introduced two classes of online heuristics called any-fit algorithm and almost-any-fit algorithm: In an AnyFit (AF) algorithm, if the current nonempty bins are B 1 ,...,B j , then the current item will not be packed into B j+1 unless it does not fit in any of B 1 ,...,B j . The FF, WF, BF and AWF algorithms satisfy this condition. Johnson proved that, for any AnyFit algorithm A and any \alpha : R_{FF}^{\infty}(\alpha) \leq R_{A}^{\infty}(\alpha) \leq R_{WF}^{\infty}(\alpha) .
In an AlmostAnyFit (AAF) algorithm, if the current nonempty bins are B 1 ,...,B j , and of these bins, B k is the unique bin with the smallest load, then the current item will not be packed into B k , unless it does not fit into any of the bins to its left. The FF, BF and AWF algorithms satisfy this condition, but WF does not.
Johnson proved that, for any AAF algorithm A and any : R_{A}^{\infty}(\alpha) = R_{FF}^{\infty}(\alpha) In particular: R_{A}^{\infty} = 1.7 . Refined-first-fit bin packing (RFF) partitions the item sizes into four ranges: \left(\frac 1 2,1\right] , \left(\frac 2 5, \frac 1 2\right] , \left(\frac 1 3, \frac 2 5\right] , and \left(0, \frac 1 3\right] .
Similarly, the bins are categorized into four classes. The next item i \in L is first assigned to its corresponding class. Inside that class, it is assigned to a bin using first-fit.
Note that this algorithm is not an Any-Fit algorithm since it may open a new bin despite the fact that the current item fits inside an open bin. This algorithm was first presented by Andrew Chi-Chih Yao, who proved that it has an approximation guarantee of RFF(L) \leq (5/3) \cdot \mathrm{OPT}(L) +5 and presented a family of lists L_k with RFF(L_k) = (5/3)\mathrm{OPT}(L_k) +1/3 for \mathrm{OPT}(L) = 6k+1 .
Harmonic-k partitions the interval of sizes (0,1] based on a Harmonic progression into k-1 pieces I_j := \left(\frac 1 {j+1}, \frac 1 j\right] for 1\leq j and I_k := \left(0, \frac 1 k\right] such that \bigcup_{j=1}^k I_j = (0,1] . This algorithm was first described by Lee and Lee.
It has a time complexity of \mathcal{O}(|L|\log(|L|)) and at each step, there are at most open bins that can be potentially used to place items, i.e., it is a -bounded space algorithm. For k \rightarrow \infty , its approximation ratio satisfies R_{Hk}^{\infty} \approx 1.6910 , and it is asymptotically tight.
Refined-harmonic combines ideas from Harmonic-k with ideas from Refined-First-Fit. It places the items larger than \tfrac 1 3 similar as in Refined-First-Fit, while the smaller items are placed using Harmonic-k. The intuition for this strategy is to reduce the huge waste for bins containing pieces that are just larger than \tfrac 1 2 .
This algorithm was first described by Lee and Lee. They proved that for k = 20 it holds that R^\infty_{RH} \leq 373/228 . Johnson proved that any AnyFit scheme A that runs on a list ordered by descending size has an asymptotic approximation ratio of 1.22 \approx \frac{11}{9} \leq R^{\infty}_A \leq \frac{5}{4} = 1.25 .
Some methods in this family are (see the linked pages for more information): First-fit-decreasing (FFD) orders the items by descending size, then calls First-Fit. Its approximation ratio is FFD(I) = \frac{11}9 \mathrm{OPT}(I) + \frac 6 9 , and this is tight. Next-fit-decreasing (NFD) orders the items by descending size, then calls Next-Fit.
Its approximate ratio is slightly less than 1.7 in the worst case. It has also been analyzed probabilistically. Next-Fit packs a list and its inverse into the same number of bins.
Therefore, Next-Fit-Increasing has the same performance as Next-Fit-Decreasing. Modified first-fit-decreasing (MFFD) , improves on FFD for items larger than half a bin by classifying items by size into four size classes large, medium, small, and tiny, corresponding to items with size > 1/2 bin, > 1/3 bin, > 1/6 bin, and smaller items respectively.
Its approximation guarantee is MFFD(I) \leq \frac {71}{60}\mathrm{OPT}(I) + 1 . Fernandez de la Vega and Lueker presented a PTAS for bin packing.
For every \varepsilon>0 , their algorithm finds a solution with size at most (1+\varepsilon)\mathrm{OPT} + 1 and runs in time \mathcal{O}(n\log(1/\varepsilon)) + \mathcal{O}_{\varepsilon}(1) , where \mathcal{O}_{\varepsilon}(1) denotes a function only dependent on 1/\varepsilon . For this algorithm, they invented the method of adaptive input rounding: the input numbers are grouped and rounded up to the value of the maximum in each group.
This yields an instance with a small number of different sizes, which can be solved exactly using the configuration linear program. Krause, Shen and Schwetman introduce this problem as a variant of optimal job scheduling: a computer has some k processors. There are some n jobs that take unit time (1), but have different memory requirements.
Each time-unit is considered a single bin. The goal is to use as few bins (=time units) as possible, while ensuring that in each bin, at most k jobs run. They present several heuristic algorithms that find a solution with at most 2 \mathrm{OPT} bins.
Kellerer and Pferschy present an algorithm with run-time O(n^2 \log{n}) , that finds a solution with at most \left\lceil\frac{3}{2}\mathrm{OPT}\right\rceil bins. Their algorithm performs a binary search for OPT. For every searched value m, it tries to pack the items into 3m/2 bins.
Cohen, Keller, Mirrokni and Zadimoghaddam study a setting where the size of the items is not known in advance, but it is a random variable. This is particularly common in cloud computing environments. While there is an upper bound on the amount of resources a certain user needs, most users use much less than the capacity.
Therefore, the cloud manager may gain a lot by slight overcommitment. This induces a variant of bin packing with chance constraints: the probability that the sum of sizes in each bin is at most B should be at least p, where p is a fixed constant (standard bin packing corresponds to p=1).
They show that, under mild assumptions, this problem is equivalent to a submodular bin packing problem, in which the "load" in each bin is not equal to the sum of items, but to a certain submodular function of it.
Text derived from https://en.wikipedia.org/w/index.php?oldid=1363095485 under CC BY-SA 4.0; modifications have been made.