Bin packing problem

In computational complexity theory, the bin packing problem is a combinatorial NP-hard problem. In it, objects of different volumes must be packed into a finite number of bins of capacity V in a way that minimizes the number of bins used.

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, creating file backup in removable 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 it is NP-hard, optimal solutions to very large instances 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 elements to be packed. The algorithm can be made much more effective by first sorting the list of elements 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.

Formal statement

Given a bin size $V$ and a list of $n$ items with sizes $a_{1},\dots ,a_{n}$ to pack, find an integer $B$ and a $B$-partition $S_{1}\cup \dots \cup S_{B}$ of $\{1,\dots ,n\}$ such that $\sum _{i\in S_{k}}a_{i}\leq V$ for all $k=1,\dots ,B$. A solution is optimal if it has minimal $B$. The $B$-value for an optimal solution is denoted OPT below. A possible Integer Linear Programming formulation of the problem is:

minimize $B=\sum _{i=1}^{n}y_{i}$
subject to	$\sum _{j=1}^{n}a_{j}x_{ij}\leq Vy_{i},$	$\forall i\in \{1,\ldots ,n\}$
	$\sum _{i=1}^{n}x_{ij}=1,$	$\forall j\in \{1,\ldots ,n\}$
	$y_{i}\in \{0,1\},$	$\forall i\in \{1,\ldots ,n\}$
	$x_{ij}\in \{0,1\},$	$\forall i\in \{1,\ldots ,n\}\,\forall j\in \{1,\ldots ,n\}$

First-fit algorithm

This is a very 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.

It is rather simple to show this algorithm achieves an approximation factor of 2. This is due to the observation that at any given time, it is impossible for 2 bins to be at most half full. The reason is that if at some point a bin was at most half full, meaning it 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 $\sum _{i=1}^{n}a_{i}>{\tfrac {B-1}{2}}V$. Because ${\tfrac {\sum _{i=1}^{n}a_{i}}{V}}$ is a lower bound of the optimum value OPT, we get that B − 1 < 2OPT and therefore B ≤ 2OPT. See analysis below for better approximation results.

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). 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. Without the sorting step, we only achieve the looser bound of 17/10 OPT + 2. 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 proved that the bound 11/9 OPT + 6/9 for FFD is tight. MFFD (a variant of FFD) uses no more than 71/60 OPT + 1 bins (i.e. bounded by about 1.18×opt, compared to about 1.22×opt for FFD). In 2010, an upper bound for the asymptotic performance ratio was decreased to 17/10 OPT + 7/10 for FF and for the absolute performance ratio - to 12/7 OPT.

For all ε > 0, Bin Packing is hard to approximate within 3/2 - ε. If such approximation exists, one could partition n non-negative numbers into two sets with the same sum in polynomial time. However, this problem is also known to be NP-hard. It is therefore impossible to propose a polynomial-time approximation scheme (PTAS) to the bin packing problem unless P = NP. Alternatively, it is possible to find a solution for any 0 < ε ≤ 1/2 in polynomial time using at most (1 + 2ε)OPT + 1 bins. This approximation type is known as asymptotic PTAS.

Exact algorithm

In, an exact algorithm for the 1-D bin-packing problem has been developed, called MTP.

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
• Packing problem
• Partition problem
• Subset sum problem
• Best fit

References

• Vazirani, Vijay V. (2003), Approximation Algorithms, Berlin: Springer, ISBN 3-540-65367-8
• Yue, Minyi (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 {{citation}}: |contribution= ignored (help); Unknown parameter |month= ignored (help)
• 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, vol. 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 {{citation}}: |contribution= ignored (help)
• 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 {{citation}}: |contribution= ignored (help)
• Yue, Minyi; Zhang, Lei (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 {{citation}}: |contribution= ignored (help); Unknown parameter |month= ignored (help)
• de la Vega, W. Fernandez; Lueker, G. S. (1981), "Bin packing can be solved within 1 + ε in linear time", Combinatorica, 1 (4), Springer Berlin / Heidelberg: 349–355, doi:10.1007/BF02579456, ISSN 0209-9683 {{citation}}: |contribution= ignored (help); Unknown parameter |month= ignored (help)
• 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
• Silvano Martello and Paolo Toth (1990), Knapsack Problems Algorithms and Computer Implementations.
• 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, p. 107-129

External links

• Packaging problem solved in PHP
• PHP Class to pack files without exceeding a given size limit
• An implementation of several bin packing heuristics in Haskell, including FFD and MFFD.
• Cutting And Packing Algorithms Research Framework, including a number of bin packing algorithms and test data.
• A simple on-line bin-packing algorithm
• Solving packaging problem in PHP
• Optimizing Three-Dimensional Bin Packing