# Bin packing problem

In the **bin packing problem**, items of different volumes must be packed into a finite number of bins or containers each of a fixed given volume in a way that minimizes the number of bins used. In computational complexity theory, it is a combinatorial NP-hard problem.[1] The decision problem (deciding if items will fit into a specified number of bins) is NP-complete.[2]

There are many variations of this problem, such as 2D packing, linear packing, packing by weight, packing by cost, and so on. They have many applications, such as filling up containers, loading trucks with weight capacity constraints, creating file backups in media and technology mapping in field-programmable gate array semiconductor chip design.

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 characterised by both a volume and a value, the problem of maximising the value of items that can fit in the bin is known as the knapsack problem.

Despite the fact that the bin packing problem has an NP-hard computational complexity, optimal solutions to very large instances of the problem can be produced with sophisticated algorithms. In addition, many heuristics have been developed: 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.[3]

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[4] 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 the 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.

## Formal statement

Given a set of bins with the same size and a list of items with sizes to pack, find an integer number of bins and a -partition of the set such that for all A solution is *optimal* if it has minimal . The -value for an optimal solution is denoted **OPT** below. A possible integer linear programming formulation of the problem is:

minimize | ||

subject to | ||

where if bin is used and if item is put into bin .[5]

## First-fit algorithm

This is a straightforward greedy approximation algorithm. The algorithm processes the items in arbitrary order. For each item, it attempts to place the item in the first bin that can accommodate the item. If no bin is found, it opens a new bin and puts the item within the new bin.

This algorithm achieves an approximation factor of 2; the number of bins used by this algorithm is no more than twice the optimal number of bins. In other words, it is impossible for 2 bins to be at most half full because such a possibility implies that at some point, exactly one bin was at most half full and a new one was opened to accommodate an item of size at most V/2. But since the first one has at least a space of *V* / 2, the algorithm will not open a new bin for any item whose size is at most *V* / 2. Only after the bin fills with more than *V* / 2 or if an item with a size larger than *V* / 2 arrives, the algorithm may open a new bin.

Thus if we have *B* bins, at least *B* − 1 bins are more than half full. Therefore, . Because is a lower bound of the optimum value *OPT*, we get that *B* − 1 < 2*OPT* and therefore *B* ≤ 2*OPT*.[6] See the analysis below for better approximation results.

Modified first fit decreasing (MFFD)[7] 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. Then it proceeds through five phases:

- Allot a bin for each large item, ordered largest to smallest.
- Proceed forward through the bins. On each: If the smallest remaining medium item does not fit, skip this bin. Otherwise, place the largest remaining medium item that fits.
- Proceed backward through those bins that do not contain a medium item. On each: If the two smallest remaining small items do not fit, skip this bin. Otherwise, place the smallest remaining small item and the largest remaining small item that fits.
- Proceed forward through all bins. If the smallest remaining item of any size class does not fit, skip this bin. Otherwise, place the largest item that fits
*and stay on this bin.* - Use FFD to pack the remaining items into new bins.

## Analysis of approximate algorithms

The *best fit decreasing* and *first fit decreasing* strategies are among the simplest heuristic algorithms for solving the bin packing problem. They have been shown to use no more than 11/9 **OPT** + 1 bins (where **OPT** is the number of bins given by the optimal solution).[8] The simpler of these, the *First Fit Decreasing* (FFD) strategy, operates by first sorting the items to be inserted in decreasing order by their sizes, and then inserting each item into the first bin in the list with sufficient remaining space. Sometimes, however, one does not have the option to sort the input, for example, when faced with an online bin packing problem. In 2007, it was proven that the bound 11/9 **OPT** + 6/9 for FFD is tight.[9] MFFD uses no more than 71/60 **OPT** + 1 bins[10] (i.e. bounded by about 1.18 **OPT**, compared to about 1.22 **OPT** for FFD). In 2013, Dósa and Sgall gave a tight upper bound for the first-fit (FF) strategy, showing that it never needs more than 17/10 **OPT** bins for any input.[11]

## Exact algorithm

Martello and Toth[12] developed an exact algorithm for the 1-D bin-packing problem, called MTP. A faster alternative is the Bin Completion algorithm proposed by Korf in 2002[13] and later improved.[14]

A further improvement was presented by Schreiber and Korf in 2013.[15] The new Improved Bin Completion algorithm is shown to be up to five orders of magnitude faster than Bin Completion on non-trivial problems with 100 items, and outperforms the BCP (branch-and-cut-and-price) algorithm by Belov and Scheithauer on problems that have fewer than 20 bins as the optimal solution. Which algorithm performs best depends on problem properties like number of items, optimal number of bins, unused space in the optimal solution and value precision.

## See also

- If the number of bins is to be fixed or constrained, and the size of the bins is to be minimised, that is a different problem which is equivalent to the Multiprocessor scheduling problem
- Guillotine problem
- Packing problems
- Partition problem
- Subset sum problem

## References

- Korte, Bernhard; Vygen, Jens (2006). "Bin-Packing".
*Combinatorial Optimization: Theory and Algorithms*. Algorithms and Combinatorics 21. Springer. pp. 426–441. doi:10.1007/3-540-29297-7_18. ISBN 978-3-540-25684-7. - Barrington, David Mix (2006). "Bin Packing". Archived from the original on 2019-02-16. Retrieved 2016-02-27.
- Lewis 2009
- Sindelar, Sitaraman & Shenoy 2011, pp. 367–378
- Martello & Toth 1990, p. 221
- Vazirani 2003, p. 74.
- Garey & Johnson 1985, pp. 65–106.
- Yue 1991, pp. 321–331.
- Dósa 2007, pp. 1–11.
- Yue & Zhang 1995, pp. 318–330.
- Dósa & Sgall 2013.
- Martello & Toth 1990, pp. 237–240.
- Korf 2002
- R. E. Korf (2003),
*An improved algorithm for optimal bin packing*. Proceedings of the International Joint Conference on Artificial Intelligence, (pp. 1252–1258) - Schreiber & Korf 2013

**Bibliography**

- Korf, Richard E. (2002),
*A new algorithm for optimal bin packing.*(PDF) - Vazirani, Vijay V. (2003),
*Approximation Algorithms*, Berlin: Springer, ISBN 3-540-65367-8 - Yue, Minyi (October 1991), "A simple proof of the inequality FFD (L) ≤ 11/9 OPT (L) + 1, ∀L for the FFD bin-packing algorithm",
*Acta Mathematicae Applicatae Sinica*,**7**(4): 321–331, doi:10.1007/BF02009683, ISSN 0168-9673 - Dósa, György (2007), "The Tight Bound of First Fit Decreasing Bin-Packing Algorithm Is FFD(I)≤(11/9)OPT(I)+6/9", in Chen, Bo; Paterson, Mike; Zhang, Guochuan (eds.),
*Combinatorics, Algorithms, Probabilistic and Experimental Methodologies*, 4614/2007, Springer Berlin / Heidelberg, pp. 1–11, doi:10.1007/978-3-540-74450-4, ISBN 978-3-540-74449-8, ISSN 0302-9743 - Xia, Binzhou; Tan, Zhiyi (2010), "Tighter bounds of the First Fit algorithm for the bin-packing problem",
*Discrete Applied Mathematics*,**158**(15): 1668–1675, doi:10.1016/j.dam.2010.05.026, ISSN 0166-218X - Garey, Michael R.; Johnson, David S. (1985), "A 71/60 theorem for bin packing*1",
*Journal of Complexity*,**1**: 65–106, doi:10.1016/0885-064X(85)90022-6 - Yue, Minyi; Zhang, Lei (July 1995), "A simple proof of the inequality MFFD(L)≤71/60 OPT(L) + 1,L for the MFFD bin-packing algorithm",
*Acta Mathematicae Applicatae Sinica*,**11**(3): 318–330, doi:10.1007/BF02011198, ISSN 0168-9673 - Fernandez de la Vega, W.; Lueker, G. S. (December 1981), "Bin packing can be solved within 1 + ε in linear time",
*Combinatorica*, Springer Berlin / Heidelberg,**1**(4): 349–355, doi:10.1007/BF02579456, ISSN 0209-9683 - Lewis, R. (2009), "A General-Purpose Hill-Climbing Method for Order Independent Minimum Grouping Problems: A Case Study in Graph Colouring and Bin Packing",
*Computers and Operations Research*,**36**(7): 2295–2310, doi:10.1016/j.cor.2008.09.004 - Martello, Silvano; Toth, Paolo (1990), "Bin-packing problem" (PDF),
*Knapsack Problems: Algorithms and Computer Implementations*, Chichester, UK: John Wiley and Sons, ISBN 0471924202 - Michael R. Garey and David S. Johnson (1979), Computers and Intractability: A Guide to the Theory of NP-Completeness. W.H. Freeman. ISBN 0-7167-1045-5. A4.1: SR1, p. 226.
- David S. Johnson, Alan J. Demers, Jeffrey D. Ullman, M. R. Garey, Ronald L. Graham. Worst-Case Performance Bounds for Simple One-Dimensional Packing Algorithms. SICOMP, Volume 3, Issue 4. 1974.
- Lodi A., Martello S., Monaci, M., Vigo, D. (2010) "Two-Dimensional Bin Packing Problems". In V.Th. Paschos (Ed.),
*Paradigms of Combinatorial Optimization*, Wiley/ISTE, pp. 107–129 - Dósa, György; Sgall, Jiří (2013). "First Fit bin packing: A tight analysis".
*30th International Symposium on Theoretical Aspects of Computer Science (STACS 2013)*. Dagstuhl, Germany. pp. 538–549. ISBN 978-3-939897-50-7. - Benkő A., Dósa G., Tuza Z. (2010) "Bin Packing/Covering with Delivery, Solved with the Evolution of Algorithms,"
*Proceedings 2010 IEEE 5th International Conference on Bio-Inspired Computing: Theories and Applications, BIC-TA 2010*, art. no. 5645312, pp. 298–302. - Sindelar, Michael; Sitaraman, Ramesh; Shenoy, Prashant (2011), "Sharing-Aware Algorithms for Virtual Machine Colocation" (PDF),
*Proceedings of 23rd ACM Symposium on Parallelism in Algorithms and Architectures (SPAA), San Jose, CA, June 2011*: 367–378 - Schreiber, Ethan L.; Korf, Richard E. (2013),
*Improved Bin Completion for Optimal Bin Packing and Number Partitioning*, IJCAI '13, Beijing, China: AAAI Press, pp. 651–658, ISBN 978-1-57735-633-2

## External links

- Optimizing Three-Dimensional Bin Packing
- Implementation of 7 classic approximate bin packing algorithms in C with results and images
- PHP Class to pack files without exceeding a given size limit
- An implementation of several bin packing heuristics in Haskell, including FFD and MFFD.
- Visualization of heuristics for 1D and 2D bin packing
- Cutting And Packing Algorithms Research Framework, including a number of bin packing algorithms and test data.
- A simple on-line bin-packing algorithm
- Fpart : open-source command-line tool to pack files (C, BSD-licensed)
- Bin Packing and Cutting Stock Solver Algorithm