Single-class algorithms

There are many simple algorithms that use the following general scheme:

• For each item in the input list:
  1. If the item fits into one of the currently open bins, then put it in one of these bins;
  2. Otherwise, open a new bin and put the new item in it.

The algorithms differ in the criterion by which they choose the open bin for the new item in step 1 (see the linked pages for more information):

• 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, ${\displaystyle NF(L)\leq 2\cdot \mathrm {OPT} (L)-1}$, and for each ${\displaystyle N\in \mathbb {N} }$ there exists a list L such that ${\displaystyle \mathrm {OPT} (L)=N}$ and ${\displaystyle NF(L)=2\cdot \mathrm {OPT} (L)-2}$.^[10] Its asymptotic approximation ratio can be somewhat improved based on the item sizes: ${\displaystyle R_{NF}^{\infty }({\text{size}}\leq \alpha )\leq 2}$ for all ${\displaystyle \alpha \geq 1/2}$ and ${\displaystyle R_{NF}^{\infty }({\text{size}}\leq \alpha )\leq 1/(1-\alpha )}$ for all ${\displaystyle \alpha \leq 1/2}$. For each algorithm A that is an AnyFit-algorithm it holds that ${\displaystyle 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 k bins open and chooses the first bin in which the item fits. Therefore, it is called a k-bounded space algorithm.^[11] For ${\displaystyle k\geq 2}$ the NkF delivers results that are improved compared to the results of NF, however, increasing k to constant values larger than 2 improves the algorithm no further in its worst-case behavior. If algorithm A is an AlmostAnyFit-algorithm and ${\displaystyle m=\lfloor 1/\alpha \rfloor \geq 2}$ then ${\displaystyle R_{A}^{\infty }({\text{size}}\leq \alpha )\leq R_{N2F}^{\infty }({\text{size}}\leq \alpha )=1+1/m}$.^[10]
• 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 ${\displaystyle FF(L)\leq \lfloor 1.7\mathrm {OPT} \rfloor }$, and there is a family of input lists L for which ${\displaystyle FF(L)}$ matches this bound.^[12]
• 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: ${\displaystyle BF(L)\leq \lfloor 1.7\mathrm {OPT} \rfloor }$, and there is a family of input lists L for which ${\displaystyle BF(L)}$ matches this bound.^[13]
• 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 ${\displaystyle NF(L)=2\cdot \mathrm {OPT} (L)-2}$. Furthermore, it holds that ${\displaystyle 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 ${\displaystyle R_{AF}^{\infty }(\alpha )=R_{NF}^{\infty }(\alpha )}$.^[10]
• 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 ${\displaystyle {\tfrac {17}{10}}}$.^[10]

In order to generalize these results, Johnson introduced two classes of online heuristics called any-fit algorithm and almost-any-fit algorithm:^[4]: 470

• In an AnyFit (AF) algorithm, if the current nonempty bins are B₁,...,B_j, then the current item will not be packed into B_j+1 unless it does not fit in any of B₁,...,B_j. The FF, WF, BF and AWF algorithms satisfy this condition. Johnson proved that, for any AnyFit algorithm A and any ${\displaystyle \alpha }$:

  ${\displaystyle 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₁,...,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 α:

  ${\displaystyle R_{A}^{\infty }(\alpha )=R_{FF}^{\infty }(\alpha )}$ In particular: ${\displaystyle R_{A}^{\infty }=1.7}$.

Refined algorithms

Better approximation ratios are possible with heuristics that are not AnyFit. These heuristics usually keep several classes of open bins, devoted to items of different size ranges (see the linked pages for more information):

• Refined-first-fit bin packing (RFF) partitions the item sizes into four ranges: ${\displaystyle \left({\frac {1}{2}},1\right]}$, ${\displaystyle \left({\frac {2}{5}},{\frac {1}{2}}\right]}$, ${\displaystyle \left({\frac {1}{3}},{\frac {2}{5}}\right]}$, and ${\displaystyle \left(0,{\frac {1}{3}}\right]}$. Similarly, the bins are categorized into four classes. The next item ${\displaystyle 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,^[14] who proved that it has an approximation guarantee of ${\displaystyle RFF(L)\leq (5/3)\cdot \mathrm {OPT} (L)+5}$ and presented a family of lists ${\displaystyle L_{k}}$ with ${\displaystyle RFF(L_{k})=(5/3)\mathrm {OPT} (L_{k})+1/3}$ for ${\displaystyle \mathrm {OPT} (L)=6k+1}$.
• Harmonic-k partitions the interval of sizes ${\displaystyle (0,1]}$ based on a Harmonic progression into ${\displaystyle k-1}$ pieces ${\displaystyle I_{j}:=\left({\frac {1}{j+1}},{\frac {1}{j}}\right]}$ for ${\displaystyle 1\leq j<k}$ and ${\displaystyle I_{k}:=\left(0,{\frac {1}{k}}\right]}$ such that ${\displaystyle \bigcup _{j=1}^{k}I_{j}=(0,1]}$. This algorithm was first described by Lee and Lee.^[15] It has a time complexity of ${\displaystyle {\mathcal {O}}(|L|\log(|L|))}$ and at each step, there are at most k open bins that can be potentially used to place items, i.e., it is a k-bounded space algorithm. For ${\displaystyle k\rightarrow \infty }$, its approximation ratio satisfies ${\displaystyle 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 ${\displaystyle {\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 ${\displaystyle {\tfrac {1}{2}}}$. This algorithm was first described by Lee and Lee.^[15] They proved that for ${\displaystyle k=20}$ it holds that ${\displaystyle R_{RH}^{\infty }\leq 373/228}$.

General lower bounds for online algorithms

Yao^[14] proved in 1980 that there can be no online algorithm with an asymptotic competitive ratio smaller than ${\displaystyle {\tfrac {3}{2}}}$. Brown^[16] and Liang^[17] improved this bound to 1.53635. Afterward, this bound was improved to 1.54014 by Vliet.^[18] In 2012, this lower bound was again improved by Békési and Galambos^[19] to ${\displaystyle {\tfrac {248}{161}}\approx 1.54037}$.

Comparison table

Algorithm	Approximation guarantee	Worst case list ${\displaystyle L}$	Time-complexity
Next-fit (NF)	${\displaystyle NF(L)\leq 2\cdot \mathrm {OPT} (L)-1}$[10]	${\displaystyle NF(L)=2\cdot \mathrm {OPT} (L)-2}$[10]	${\displaystyle {\mathcal {O}}(|L|)}$
First-fit (FF)	${\displaystyle FF(L)\leq \lfloor 1.7\mathrm {OPT} (L)\rfloor }$[12]	${\displaystyle FF(L)=\lfloor 1.7\mathrm {OPT} (L)\rfloor }$[12]	${\displaystyle {\mathcal {O}}(|L|\log(|L|))}$[10]
Best-fit (BF)	${\displaystyle BF(L)\leq \lfloor 1.7\mathrm {OPT} (L)\rfloor }$[13]	${\displaystyle BF(L)=\lfloor 1.7\mathrm {OPT} (L)\rfloor }$[13]	${\displaystyle {\mathcal {O}}(|L|\log(|L|))}$[10]
Worst-Fit (WF)	${\displaystyle WF(L)\leq 2\cdot \mathrm {OPT} (L)-1}$[10]	${\displaystyle WF(L)=2\cdot \mathrm {OPT} (L)-2}$[10]	${\displaystyle {\mathcal {O}}(|L|\log(|L|))}$[10]
Almost-Worst-Fit (AWF)	${\displaystyle R_{AWF}^{\infty }\leq 17/10}$[10]	${\displaystyle R_{AWF}^{\infty }=17/10}$[10]	${\displaystyle {\mathcal {O}}(|L|\log(|L|))}$[10]
Refined-First-Fit (RFF)	${\displaystyle RFF(L)\leq (5/3)\cdot \mathrm {OPT} (L)+5}$[14]	${\displaystyle RFF(L)=(5/3)\mathrm {OPT} (L)+1/3}$ (for ${\displaystyle \mathrm {OPT} (L)=6k+1}$)[14]	${\displaystyle {\mathcal {O}}(|L|\log(|L|))}$[14]
Harmonic-k (Hk)	${\displaystyle R_{Hk}^{\infty }\leq 1.69103}$ for ${\displaystyle k\rightarrow \infty }$[15]	${\displaystyle R_{Hk}^{\infty }\geq 1.69103}$[15]	${\displaystyle {\mathcal {O}}(|L|\log(|L|)}$[15]
Refined Harmonic (RH)	${\displaystyle R_{RH}^{\infty }\leq 373/228\approx 1.63597}$[15]		${\displaystyle {\mathcal {O}}(|L|)}$[15]
Modified Harmonic (MH)	${\displaystyle R_{MH}^{\infty }\leq 538/33\approx 1.61562}$[20]
Modified Harmonic 2 (MH2)	${\displaystyle R_{MH2}^{\infty }\leq 239091/148304\approx 1.61217}$[20]
Harmonic + 1 (H+1)		${\displaystyle R_{H+1}^{\infty }\geq 1.59217}$[21]
Harmonic ++ (H++)	${\displaystyle R_{H++}^{\infty }\leq 1.58889}$[21]	${\displaystyle R_{H++}^{\infty }\geq 1.58333}$[21]

Multiplicative approximation

The simplest technique used by offline approximation schemes is the following:

• Ordering the input list by descending size;
• Run an online algorithm on the ordered list.

Johnson^[10] proved that any AnyFit scheme A that runs on a list ordered by descending size has an asymptotic approximation ratio of

${\displaystyle 1.22\approx {\frac {11}{9}}\leq R_{A}^{\infty }\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 ${\displaystyle FFD(I)={\frac {11}{9}}\mathrm {OPT} (I)+{\frac {6}{9}}}$, and this is tight.^[22]
• 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.^[23] It has also been analyzed probabilistically.^[24] 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.^[25]
• Modified first-fit-decreasing (MFFD)^[26], 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 ${\displaystyle MFFD(I)\leq {\frac {71}{60}}\mathrm {OPT} (I)+1}$.^[27]

Fernandez de la Vega and Lueker^[28] presented a PTAS for bin packing. For every ${\displaystyle \varepsilon >0}$, their algorithm finds a solution with size at most ${\displaystyle (1+\varepsilon )\mathrm {OPT} +1}$ and runs in time ${\displaystyle {\mathcal {O}}(n\log(1/\varepsilon ))+{\mathcal {O}}_{\varepsilon }(1)}$, where ${\displaystyle {\mathcal {O}}_{\varepsilon }(1)}$ denotes a function only dependent on ${\displaystyle 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.^[29]

Additive approximation

The Karmarkar-Karp bin packing algorithm finds a solution with size at most ${\displaystyle \mathrm {OPT} +{\mathcal {O}}(\log ^{2}(\mathrm {OPT} ))}$, and runs in time polynomial in n (the polynomial has a high degree, at least 8).

Rothvoss^[30] presented an algorithm that generates a solution with at most ${\displaystyle \mathrm {OPT} +{\mathcal {O}}(\log(\mathrm {OPT} )\cdot \log \log(\mathrm {OPT} ))}$ bins.

Hoberg and Rothvoss^[31] improved this algorithm to generate a solution with at most ${\displaystyle \mathrm {OPT} +{\mathcal {O}}(\log(\mathrm {OPT} ))}$ bins. The algorithm is randomized, and its running-time is polynomial in n.

Comparison table

Algorithm	Approximation guarantee	Worst case instance
First-fit-decreasing (FFD)	${\displaystyle \mathrm {FFD} (I)\leq {\frac {11}{9}}\mathrm {OPT} (I)+{\frac {6}{9}}}$[22]	${\displaystyle \mathrm {FFD} (I)={\frac {11}{9}}\mathrm {OPT} (I)+{\frac {6}{9}}}$[22]
Modified-first-fit-decreasing (MFFD)	${\displaystyle \mathrm {MFFD} (I)\leq {\frac {71}{60}}\mathrm {OPT} (I)+1}$[27]	${\displaystyle R_{\mathrm {MFFD} }^{\infty }\geq {\frac {71}{60}}}$[26]
Karmarkar and Karp	${\displaystyle \mathrm {KK} (I)\leq \mathrm {OPT} (I)+O(\log ^{2}{\mathrm {OPT} (I)})}$[32]
Rothvoss	${\displaystyle \mathrm {HB} (I)\leq \mathrm {OPT} (I)+O(\log {\mathrm {OPT} (I)}\log \log {\mathrm {OPT} (I)})}$[30]
Hoberg and Rothvoss	${\displaystyle \mathrm {HB} (I)\leq \mathrm {OPT} (I)+O(\log {\mathrm {OPT} (I)})}$[31]

Exact algorithms

Martello and Toth^[33] developed an exact algorithm for the 1-dimensional bin-packing problem, called MTP. A faster alternative is the Bin Completion algorithm proposed by Korf in 2002^[34] and later improved.^[35]

A further improvement was presented by Schreiber and Korf in 2013.^[36] 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 the number of items, the optimal number of bins, unused space in the optimal solution and value precision.

Small number of different sizes

A special case of bin packing is when there is a small number d of different item sizes. There can be many different items of each size. This case is also called high-multiplicity bin packing, and It admits more efficient algorithms than the general problem.

Variants

The problem has two main variants.

1. In the first variant, called bin-packing with size-increasing fragmentation (BP-SIF), each item may be fragmented; overhead units are added to the size of every fragment.
2. In the second variant, called bin-packing with size-preserving fragmentation (BP-SPF) each item has a size and a cost; fragmenting an item increases its cost but does not change its size.

Computational complexity

Mandal, Chakrabary and Ghose^[37] proved that BP-SPF is NP-hard.

Menakerman and Rom^[38] showed that BP-SIF and BP-SPF are both strongly NP-hard. Despite the hardness, they present several algorithms and investigate their performance. Their algorithms use classic algorithms for bin-packing, like next-fit and first-fit decreasing, as a basis for their algorithms.

Bertazzi, Golden and Wang^[39] introduced a variant of BP-SIF with ${\displaystyle 1-x}$ split rule: an item is allowed to be split in only one way according to its size. It is useful for the vehicle routing problem for example. In their paper, they provide the worst-case performance bound of the variant.

Shachnai, Tamir and Yehezkeli^[40] developed approximation schemes for BP-SIF and BP-SPF; a dual PTAS (a PTAS for the dual version of the problem), an asymptotic PTAS called APTAS, and a dual asymptotic FPTAS called AFPTAS for both versions.

Ekici^[41] introduced a variant of BP-SPF in which some items are in conflict, and it is forbidden to pack fragments of conflicted items into the same bin. They proved that this variant, too, is NP-hard.

Cassazza and Ceselli^[42] introduced a variant with no cost and no overhead, and the number of bins is fixed. However, the number of fragmentations should be minimized. They present mathematical programming algorithms for both exact and approximate solutions.

Related problems

The problem of fractional knapsack with penalties was introduced by Malaguti, Monaci, Paronuzzi and Pferschy.^[43] They developed an FPTAS and a dynamic program for the problem, and they showed an extensive computational study comparing the performance of their models. See also: Fractional job scheduling.