Bin packing problem

Last updated

The bin packing problem [1] [2] [3] [4] 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, [5] and technology mapping in FPGA semiconductor chip design.

Contents

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. [6]

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 [7] 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 [8] :226 Garey and Johnson list the bin packing problem under the reference [SR1]. They define its decision variant as follows.

Instance: Finite set of items, a size for each , a positive integer bin capacity , and a positive integer .

Question: Is there a partition of into disjoint sets such that the sum of the sizes of the items in each is or less?

Note that in the literature often an equivalent notation is used, where and for each . Furthermore, research is mostly interested in the optimization variant, which asks for the smallest possible value of . A solution is optimal if it has minimal . The -value for an optimal solution for a set of items is denoted by or just if the set of items is clear from the context.

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 . [9]

Hardness of bin packing

The bin packing problem is strongly NP-complete. This can be proven by reducing the strongly NP-complete 3-partition problem to bin packing. [8]

Furthermore, there can be no approximation algorithm with absolute approximation ratio smaller than unless . This can be proven by a reduction from the partition problem: [10] given an instance of Partition where the sum of all input numbers is , construct an instance of bin-packing in which the bin size is T. 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 3/2 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 K, and solvable in polynomial time for any fixed bin capacity B. [8]

Approximation algorithms for bin packing

To measure the performance of an approximation algorithm there are two approximation ratios considered in the literature. For a given list of items the number denotes the number of bins used when algorithm is applied to list , while denotes the optimum number for this list. The absolute worst-case performance ratio for an algorithm is defined as

On the other hand, the asymptotic worst-case ratio is defined as

Equivalently, is the smallest number such that there exists some constant K, such that for all lists L: [4]

.

Additionally, one can restrict the lists to those for which all items have a size of at most . For such lists, the bounded size performance ratios are denoted as and .

Approximation algorithms for bin packing can be classified into two categories:

  1. Online heuristics, that consider the items in a given order and place them one by one inside the bins. These heuristics are also applicable to the offline version of this problem.
  2. Offline heuristics, that modify the given list of items e.g. by sorting the items by size. These algorithms are no longer applicable to the online variant of this problem. However, they have an improved approximation guarantee while maintaining the advantage of their small time-complexity. A sub-category of offline heuristics is asymptotic approximation schemes. These algorithms have an approximation guarantee of the form for some constant that may depend on . For an arbitrarily large these algorithms get arbitrarily close to . However, this comes at the cost of a (drastically) increased time complexity compared to the heuristical approaches.

Online heuristics

In the online version of the bin packing problem, the items arrive one after another and the (irreversible) decision where to place an item has to be made before knowing the next item or even if there will be another one. A diverse set of offline and online heuristics for bin-packing have been studied by David S. Johnson on his Ph.D. thesis. [11]

Single-class algorithms

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

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):

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

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):

General lower bounds for online algorithms

Yao [15] proved in 1980 that there can be no online algorithm with an asymptotic competitive ratio smaller than . Brown [17] and Liang [18] improved this bound to 1.53635. Afterward, this bound was improved to 1.54014 by Vliet. [19] In 2012, this lower bound was again improved by Békési and Galambos [20] to .

Comparison table

AlgorithmApproximation guaranteeWorst case list Time-complexity
Next-fit (NF) [11] [11]
First-fit (FF) [13] [13] [11]
Best-fit (BF) [14] [14] [11]
Worst-Fit (WF) [11] [11] [11]
Almost-Worst-Fit (AWF) [11] [11] [11]
Refined-First-Fit (RFF) [15] (for ) [15] [15]
Harmonic-k (Hk) for [16] [16] [16]
Refined Harmonic (RH) [16] [16]
Modified Harmonic (MH) [21]
Modified Harmonic 2 (MH2) [21]
Harmonic + 1 (H+1) [22]
Harmonic ++ (H++) [22] [22]

Offline algorithms

In the offline version of bin packing, the algorithm can see all the items before starting to place them into bins. This allows to attain improved approximation ratios.

Multiplicative approximation

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

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

.

Some methods in this family are (see the linked pages for more information):

Fernandez de la Vega and Lueker [29] presented a PTAS for bin packing. For every , their algorithm finds a solution with size at most and runs in time , where denotes a function only dependent on . 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. [30]

Additive approximation

The Karmarkar-Karp bin packing algorithm finds a solution with size at most , and runs in time polynomial in n (the polynomial has a high degree, at least 8).

Rothvoss [31] presented an algorithm that generates a solution with at most bins.

Hoberg and Rothvoss [32] improved this algorithm to generate a solution with at most bins. The algorithm is randomized, and its running-time is polynomial in n.

Comparison table

AlgorithmApproximation guaranteeWorst case instance
First-fit-decreasing (FFD) [23] [23]
Modified-first-fit-decreasing (MFFD) [28] [27]
Karmarkar and Karp [33]
Rothvoss [31]
Hoberg and Rothvoss [32]

Exact algorithms

Martello and Toth [34] 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 [35] and later improved. [36]

A further improvement was presented by Schreiber and Korf in 2013. [37] 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.

Bin-packing with fragmentation

Bin-packing with fragmentation or fragmentable object bin-packing is a variant of the bin packing problem in which it is allowed to break items into parts and put each part separately on a different bin. Breaking items into parts may allow for improving the overall performance, for example, minimizing the number of total bin. Moreover, the computational problem of finding an optimal schedule may become easier, as some of the optimization variables become continuous. On the other hand, breaking items apart might be costly. The problem was first introduced by Mandal, Chakrabary and Ghose. [38]

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 [38] proved that BP-SPF is NP-hard.

Menakerman and Rom [39] 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 [40] introduced a variant of BP-SIF with 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 [41] 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 [42] 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 [43] 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.

The problem of fractional knapsack with penalties was introduced by Malaguti, Monaci, Paronuzzi and Pferschy. [44] 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.

Performance with divisible item sizes

An important special case of bin packing is that the item sizes form a divisible sequence (also called factored). A special case of divisible item sizes occurs in memory allocation in computer systems, where the item sizes are all powers of 2. If the item sizes are divisible, then some of the heuristic algorithms for bin packing find an optimal solution. [45]

Cardinality constraints on the bins

There is a variant of bin packing in which there are cardinality constraints on the bins: each bin can contain at most k items, for some fixed integer k.

Non-additive functions

There are various ways to extend the bin-packing model to more general cost and load functions:

In the bin packing problem, the size of the bins is fixed and their number can be enlarged (but should be as small as possible).

In contrast, in the multiway number partitioning problem, the number of bins is fixed and their size can be enlarged. The objective is to find a partition in which the bin sizes are as nearly equal is possible (in the variant called multiprocessor scheduling problem or minimum makespan problem, the goal is specifically to minimize the size of the largest bin).

In the inverse bin packing problem, [50] both the number of bins and their sizes are fixed, but the item sizes can be changed. The objective is to achieve the minimum perturbation to the item size vector so that all the items can be packed into the prescribed number of bins.

In the maximum resource bin packing problem, [51] the goal is to maximize the number of bins used, such that, for some ordering of the bins, no item in a later bin fits in an earlier bin. In a dual problem, the number of bins is fixed, and the goal is to minimize the total number or the total size of items placed into the bins, such that no remaining item fits into an unfilled bin.

In the bin covering problem , the bin size is bounded from below: the goal is to maximize the number of bins used such that the total size in each bin is at least a given threshold.

In the fair indivisible chore allocation problem (a variant of fair item allocation ), the items represent chores, and there are different people each of whom attributes a different difficulty-value to each chore. The goal is to allocate to each person a set of chores with an upper bound on its total difficulty-value (thus, each person corresponds to a bin). Many techniques from bin packing are used in this problem too. [52]

In the guillotine cutting problem, both the items and the "bins" are two-dimensional rectangles rather than one-dimensional numbers, and the items have to be cut from the bin using end-to-end cuts.

In the selfish bin packing problem, each item is a player who wants to minimize its cost. [53]

There is also a variant of bin packing in which the cost that should be minimized is not the number of bins, but rather a certain concave function of the number of items in each bin. [48]

Other variants are two-dimensional bin packing, [54] three-dimensional bin packing, [55] bin packing with delivery, [56]

Resources

Related Research Articles

<span class="mw-page-title-main">Knapsack problem</span> Problem in combinatorial optimization

The knapsack problem is the following problem in combinatorial optimization:

In computer science and operations research, approximation algorithms are efficient algorithms that find approximate solutions to optimization problems with provable guarantees on the distance of the returned solution to the optimal one. Approximation algorithms naturally arise in the field of theoretical computer science as a consequence of the widely believed P ≠ NP conjecture. Under this conjecture, a wide class of optimization problems cannot be solved exactly in polynomial time. The field of approximation algorithms, therefore, tries to understand how closely it is possible to approximate optimal solutions to such problems in polynomial time. In an overwhelming majority of the cases, the guarantee of such algorithms is a multiplicative one expressed as an approximation ratio or approximation factor i.e., the optimal solution is always guaranteed to be within a (predetermined) multiplicative factor of the returned solution. However, there are also many approximation algorithms that provide an additive guarantee on the quality of the returned solution. A notable example of an approximation algorithm that provides both is the classic approximation algorithm of Lenstra, Shmoys and Tardos for scheduling on unrelated parallel machines.

The Frank–Wolfe algorithm is an iterative first-order optimization algorithm for constrained convex optimization. Also known as the conditional gradient method, reduced gradient algorithm and the convex combination algorithm, the method was originally proposed by Marguerite Frank and Philip Wolfe in 1956. In each iteration, the Frank–Wolfe algorithm considers a linear approximation of the objective function, and moves towards a minimizer of this linear function.

In computer science, particularly the study of approximation algorithms, an L-reduction is a transformation of optimization problems which linearly preserves approximability features; it is one type of approximation-preserving reduction. L-reductions in studies of approximability of optimization problems play a similar role to that of polynomial reductions in the studies of computational complexity of decision problems.

Stochastic approximation methods are a family of iterative methods typically used for root-finding problems or for optimization problems. The recursive update rules of stochastic approximation methods can be used, among other things, for solving linear systems when the collected data is corrupted by noise, or for approximating extreme values of functions which cannot be computed directly, but only estimated via noisy observations.

In the mathematical theory of probability, the drift-plus-penalty method is used for optimization of queueing networks and other stochastic systems.

The strip packing problem is a 2-dimensional geometric minimization problem. Given a set of axis-aligned rectangles and a strip of bounded width and infinite height, determine an overlapping-free packing of the rectangles into the strip, minimizing its height. This problem is a cutting and packing problem and is classified as an Open Dimension Problem according to Wäscher et al.

Maximin share (MMS) is a criterion of fair item allocation. Given a set of items with different values, the 1-out-of-n maximin-share is the maximum value that can be gained by partitioning the items into parts and taking the part with the minimum value. An allocation of items among agents with different valuations is called MMS-fair if each agent gets a bundle that is at least as good as his/her 1-out-of-n maximin-share. MMS fairness is a relaxation of the criterion of proportionality - each agent gets a bundle that is at least as good as the equal split ( of every resource). Proportionality can be guaranteed when the items are divisible, but not when they are indivisible, even if all agents have identical valuations. In contrast, MMS fairness can always be guaranteed to identical agents, so it is a natural alternative to proportionality even when the agents are different.

In computer science, multiway number partitioning is the problem of partitioning a multiset of numbers into a fixed number of subsets, such that the sums of the subsets are as similar as possible. It was first presented by Ronald Graham in 1969 in the context of the identical-machines scheduling problem. The problem is parametrized by a positive integer k, and called k-way number partitioning. The input to the problem is a multiset S of numbers, whose sum is k*T.

In the bin covering problem, items of different sizes must be packed into a finite number of bins or containers, each of which must contain at least a certain given total size, in a way that maximizes the number of bins used.

The multifit algorithm is an algorithm for multiway number partitioning, originally developed for the problem of identical-machines scheduling. It was developed by Coffman, Garey and Johnson. Its novelty comes from the fact that it uses an algorithm for another famous problem - the bin packing problem - as a subroutine.

Next-fit is an online algorithm for bin packing. Its input is a list of items of different sizes. Its output is a packing - a partition of the items into bins of fixed capacity, such that the sum of sizes of items in each bin is at most the capacity. Ideally, we would like to use as few bins as possible, but minimizing the number of bins is an NP-hard problem. The next-fit algorithm uses the following heuristic:

Best-fit is an online algorithm for bin packing. Its input is a list of items of different sizes. Its output is a packing - a partition of the items into bins of fixed capacity, such that the sum of sizes of items in each bin is at most the capacity. Ideally, we would like to use as few bins as possible, but minimizing the number of bins is an NP-hard problem. The best-fit algorithm uses the following heuristic:

First-fit (FF) is an online algorithm for bin packing. Its input is a list of items of different sizes. Its output is a packing - a partition of the items into bins of fixed capacity, such that the sum of sizes of items in each bin is at most the capacity. Ideally, we would like to use as few bins as possible, but minimizing the number of bins is an NP-hard problem. The first-fit algorithm uses the following heuristic:

Harmonic bin-packing is a family of online algorithms for bin packing. The input to such an algorithm is a list of items of different sizes. The output is a packing - a partition of the items into bins of fixed capacity, such that the sum of sizes of items in each bin is at most the capacity. Ideally, we would like to use as few bins as possible, but minimizing the number of bins is an NP-hard problem.

First-fit-decreasing (FFD) is an algorithm for bin packing. Its input is a list of items of different sizes. Its output is a packing - a partition of the items into bins of fixed capacity, such that the sum of sizes of items in each bin is at most the capacity. Ideally, we would like to use as few bins as possible, but minimizing the number of bins is an NP-hard problem, so we use an approximately-optimal heuristic.

Next-fit-decreasing (NFD) is an algorithm for bin packing. Its input is a list of items of different sizes. Its output is a packing - a partition of the items into bins of fixed capacity, such that the sum of sizes of items in each bin is at most the capacity. Ideally, we would like to use as few bins as possible, but minimizing the number of bins is an NP-hard problem. The NFD algorithm uses the following heuristic:

The configuration linear program (configuration-LP) is a linear programming technique used for solving combinatorial optimization problems. It was introduced in the context of the cutting stock problem. Later, it has been applied to the bin packing and job scheduling problems. In the configuration-LP, there is a variable for each possible configuration - each possible multiset of items that can fit in a single bin. Usually, the number of configurations is exponential in the problem size, but in some cases it is possible to attain approximate solutions using only a polynomial number of configurations.


High-multiplicity bin packing is a special case of the bin packing problem, in which the number of different item-sizes is small, while the number of items with each size is large. While the general bin-packing problem is NP-hard, the high-multiplicity setting can be solved in polynomial time, assuming that the number of different sizes is a fixed constant.

The Karmarkar–Karp (KK) bin packing algorithms are several related approximation algorithm for the bin packing problem. The bin packing problem is a problem of packing items of different sizes into bins of identical capacity, such that the total number of bins is as small as possible. Finding the optimal solution is computationally hard. Karmarkar and Karp devised an algorithm that runs in polynomial time and finds a solution with at most bins, where OPT is the number of bins in the optimal solution. They also devised several other algorithms with slightly different approximation guarantees and run-time bounds.

References

  1. Martello, Silvano; Toth, Paolo (1990), "Bin-packing problem" (PDF), Knapsack Problems: Algorithms and Computer Implementations , Chichester, UK: John Wiley and Sons, ISBN   0471924202
  2. 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.
  3. Barrington, David Mix (2006). "Bin Packing". Archived from the original on 2019-02-16. Retrieved 2016-02-27.
  4. 1 2 3 Coffman Jr., Edward G.; Csirik, János; Galambos, Gábor; Martello, Silvano; Vigo, Daniele (2013), Pardalos, Panos M.; Du, Ding-Zhu; Graham, Ronald L. (eds.), "Bin Packing Approximation Algorithms: Survey and Classification", Handbook of Combinatorial Optimization, New York, NY: Springer, pp. 455–531, doi:10.1007/978-1-4419-7997-1_35, ISBN   978-1-4419-7997-1 , retrieved 2021-08-08
  5. "DHCPv6-PD - First steps" . Retrieved 12 June 2024.
  6. Lewis, R. (2009), "A General-Purpose Hill-Climbing Method for Order Independent Minimum Grouping Problems: A Case Study in Graph Colouring and Bin Packing" (PDF), Computers and Operations Research, 36 (7): 2295–2310, doi:10.1016/j.cor.2008.09.004, S2CID   1577334
  7. 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
  8. 1 2 3 Garey, M. R.; Johnson, D. S. (1979). Victor Klee (ed.). Computers and Intractability: A Guide to the Theory of NP-Completeness. A Series of Books in the Mathematical Sciences. San Francisco, Calif.: W. H. Freeman and Co. pp.  x+338. ISBN   0-7167-1045-5. MR   0519066.
  9. Martello & Toth 1990 , p. 221
  10. Vazirani, Vijay V. (14 March 2013). Approximation Algorithms. Springer Berlin Heidelberg. p. 74. ISBN   978-3662045657.
  11. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Johnson, David S (1973). "Near-optimal bin packing algorithms" (PDF). Massachusetts Institute of Technology.
  12. Gonzalez, Teofilo F. (23 May 2018). Handbook of approximation algorithms and metaheuristics. Volume 2 Contemporary and emerging applications. Taylor & Francis Incorporated. ISBN   9781498770156.
  13. 1 2 3 Dósa, György; Sgall, Jiri (2013). "First Fit bin packing: A tight analysis". 30th International Symposium on Theoretical Aspects of Computer Science (STACS 2013). 20. Schloss Dagstuhl–Leibniz-Zentrum für Informatik: 538–549. doi: 10.4230/LIPIcs.STACS.2013.538 .
  14. 1 2 3 György, Dósa; Sgall, Jirí (2014). "Optimal Analysis of Best Fit Bin Packing". Automata, Languages, and Programming. Lecture Notes in Computer Science. Vol. 8572. pp. 429–441. doi:10.1007/978-3-662-43948-7_36. ISBN   978-3-662-43947-0.{{cite book}}: |journal= ignored (help)
  15. 1 2 3 4 5 Yao, Andrew Chi-Chih (April 1980). "New Algorithms for Bin Packing". Journal of the ACM. 27 (2): 207–227. doi: 10.1145/322186.322187 . S2CID   7903339.
  16. 1 2 3 4 5 6 7 Lee, C. C.; Lee, D. T. (July 1985). "A simple online bin-packing algorithm". Journal of the ACM. 32 (3): 562–572. doi: 10.1145/3828.3833 . S2CID   15441740.
  17. Donna J, Brown (1979). "A Lower Bound for On-Line One-Dimensional Bin Packing Algorithms" (PDF). Technical Rept. Archived (PDF) from the original on March 17, 2022.
  18. Liang, Frank M. (1980). "A lower bound for on-line bin packing". Information Processing Letters. 10 (2): 76–79. doi:10.1016/S0020-0190(80)90077-0.
  19. van Vliet, André (1992). "An improved lower bound for on-line bin packing algorithms". Information Processing Letters. 43 (5): 277–284. doi:10.1016/0020-0190(92)90223-I.
  20. Balogh, János; Békési, József; Galambos, Gábor (July 2012). "New lower bounds for certain classes of bin packing algorithms". Theoretical Computer Science. 440–441: 1–13. doi: 10.1016/j.tcs.2012.04.017 .
  21. 1 2 Ramanan, Prakash; Brown, Donna J; Lee, C.C; Lee, D.T (September 1989). "On-line bin packing in linear time". Journal of Algorithms. 10 (3): 305–326. doi:10.1016/0196-6774(89)90031-X. hdl: 2142/74206 .
  22. 1 2 3 Seiden, Steven S. (2002). "On the online bin packing problem". Journal of the ACM. 49 (5): 640–671. doi:10.1145/585265.585269. S2CID   14164016.
  23. 1 2 3 Dósa, György (2007). "The Tight Bound of First Fit Decreasing Bin-Packing Algorithm Is FFD(I) ≤ 11/9\mathrm{OPT}(I) + 6/9". Combinatorics, Algorithms, Probabilistic and Experimental Methodologies. ESCAPE. doi:10.1007/978-3-540-74450-4_1.
  24. Baker, B. S.; Coffman, Jr., E. G. (1981-06-01). "A Tight Asymptotic Bound for Next-Fit-Decreasing Bin-Packing". SIAM Journal on Algebraic and Discrete Methods. 2 (2): 147–152. doi:10.1137/0602019. ISSN   0196-5212.{{cite journal}}: CS1 maint: multiple names: authors list (link)
  25. Csirik, J.; Galambos, G.; Frenk, J.B.G.; Frieze, A.M.; Rinnooy Kan, A.H.G. (1986-11-01). "A probabilistic analysis of the next fit decreasing bin packing heuristic". Operations Research Letters. 5 (5): 233–236. doi:10.1016/0167-6377(86)90013-1. hdl: 1765/11645 . ISSN   0167-6377. S2CID   50663185.
  26. Fisher, David C. (1988-12-01). "Next-fit packs a list and its reverse into the same number of bins". Operations Research Letters. 7 (6): 291–293. doi:10.1016/0167-6377(88)90060-0. ISSN   0167-6377.
  27. 1 2 Johnson, David S; Garey, Michael R (October 1985). "A 7160 theorem for bin packing". Journal of Complexity. 1 (1): 65–106. doi: 10.1016/0885-064X(85)90022-6 .
  28. 1 2 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. S2CID   118263129.
  29. Fernandez de la Vega, W.; Lueker, G. S. (1981). "Bin packing can be solved within 1 + ε in linear time". Combinatorica. 1 (4): 349–355. doi:10.1007/BF02579456. ISSN   1439-6912. S2CID   10519631.
  30. Claire Mathieu. "Approximation Algorithms Part I, Week 3: bin packing". Coursera. Archived from the original on 2021-07-15.
  31. 1 2 Rothvoß, T. (2013-10-01). "Approximating Bin Packing within O(log OPT · Log Log OPT) Bins". 2013 IEEE 54th Annual Symposium on Foundations of Computer Science. pp. 20–29. arXiv: 1301.4010 . doi:10.1109/FOCS.2013.11. ISBN   978-0-7695-5135-7. S2CID   15905063.
  32. 1 2 Hoberg, Rebecca; Rothvoss, Thomas (2017-01-01), "A Logarithmic Additive Integrality Gap for Bin Packing", Proceedings of the 2017 Annual ACM-SIAM Symposium on Discrete Algorithms, Proceedings, Society for Industrial and Applied Mathematics, pp. 2616–2625, arXiv: 1503.08796 , doi: 10.1137/1.9781611974782.172 , ISBN   978-1-61197-478-2, S2CID   1647463
  33. Karmarkar, Narendra; Karp, Richard M. (November 1982). "An efficient approximation scheme for the one-dimensional bin-packing problem". 23rd Annual Symposium on Foundations of Computer Science (SFCS 1982): 312–320. doi:10.1109/SFCS.1982.61. S2CID   18583908.
  34. Martello & Toth 1990 , pp. 237–240.
  35. Korf, Richard E. (2002). A new algorithm for optimal bin packing (PDF). AAAI-02.
  36. R. E. Korf (2003), An improved algorithm for optimal bin packing . Proceedings of the International Joint Conference on Artificial Intelligence, (pp. 1252–1258)
  37. Schreiber, Ethan L.; Korf, Richard E. (2013), "Improved Bin Completion for Optimal Bin Packing and Number Partitioning" (PDF), Proceedings of the Twenty-Third International Joint Conference on Artificial Intelligence, IJCAI '13, Beijing, China: AAAI Press, pp. 651–658, ISBN   978-1-57735-633-2
  38. 1 2 Mandal, C. A.; Chakrabarti, P. P.; Ghose, S. (1998-06-01). "Complexity of fragmentable object bin packing and an application". Computers & Mathematics with Applications. 35 (11): 91–97. doi:10.1016/S0898-1221(98)00087-X. ISSN   0898-1221.
  39. Nir Menakerman and Raphael Rom "Bin Packing with Item Fragmentation". Algorithms and Data Structures, 7th International Workshop, WADS 2001, Providence, RI, USA, August 8-10, 2001, Proceedings.
  40. Bertazzi, Luca; Golden, Bruce; Wang, Xingyin (2019-05-31). "The Bin Packing Problem with Item Fragmentation:A worst-case analysis". Discrete Applied Mathematics. GO X Meeting, Rigi Kaltbad (CH), July 10--14, 2016. 261: 63–77. doi: 10.1016/j.dam.2018.08.023 . ISSN   0166-218X. S2CID   125361557.
  41. Shachnai, Hadas; Tamir, Tami; Yehezkely, Omer (2006). "Approximation Schemes for Packing with Item Fragmentation". In Erlebach, Thomas; Persinao, Giuseppe (eds.). Approximation and Online Algorithms. Lecture Notes in Computer Science. Vol. 3879. Berlin, Heidelberg: Springer. pp. 334–347. doi:10.1007/11671411_26. ISBN   978-3-540-32208-5.
  42. Ekici, Ali (2021-02-01). "Bin Packing Problem with Conflicts and Item Fragmentation". Computers & Operations Research. 126: 105113. doi:10.1016/j.cor.2020.105113. ISSN   0305-0548. S2CID   225002556.
  43. Casazza, Marco; Ceselli, Alberto (2014-06-01). "Mathematical programming algorithms for bin packing problems with item fragmentation". Computers & Operations Research. 46: 1–11. doi:10.1016/j.cor.2013.12.008. ISSN   0305-0548.
  44. Malaguti, Enrico; Monaci, Michele; Paronuzzi, Paolo; Pferschy, Ulrich (2019-03-16). "Integer optimization with penalized fractional values: The Knapsack case". European Journal of Operational Research. 273 (3): 874–888. doi:10.1016/j.ejor.2018.09.020. hdl: 11585/657029 . ISSN   0377-2217. S2CID   31722681.
  45. Coffman, E. G; Garey, M. R; Johnson, D. S (1987-12-01). "Bin packing with divisible item sizes". Journal of Complexity. 3 (4): 406–428. doi:10.1016/0885-064X(87)90009-4. ISSN   0885-064X.
  46. Krause, K. L.; Shen, V. Y.; Schwetman, H. D. (1975-10-01). "Analysis of Several Task-Scheduling Algorithms for a Model of Multiprogramming Computer Systems". Journal of the ACM. 22 (4): 522–550. doi: 10.1145/321906.321917 . ISSN   0004-5411. S2CID   10214857.
  47. Kellerer, H.; Pferschy, U. (1999-01-01). "Cardinality constrained bin-packing problems". Annals of Operations Research. 92: 335–348. doi:10.1023/A:1018947117526. ISSN   1572-9338. S2CID   28963291.
  48. 1 2 Anily, Shoshana; Bramel, Julien; Simchi-Levi, David (1994-04-01). "Worst-Case Analysis of Heuristics for the Bin Packing Problem with General Cost Structures". Operations Research. 42 (2): 287–298. doi:10.1287/opre.42.2.287. ISSN   0030-364X.
  49. Cohen, Maxime C.; Keller, Philipp W.; Mirrokni, Vahab; Zadimoghaddam, Morteza (2019-07-01). "Overcommitment in Cloud Services: Bin Packing with Chance Constraints". Management Science. 65 (7): 3255–3271. arXiv: 1705.09335 . doi:10.1287/mnsc.2018.3091. ISSN   0025-1909. S2CID   159270392.
  50. Chung, Yerim; Park, Myoung-Ju (2015-01-01). "Notes on inverse bin-packing problems". Information Processing Letters. 115 (1): 60–68. doi:10.1016/j.ipl.2014.09.005. ISSN   0020-0190.
  51. Boyar, Joan; Epstein, Leah; Favrholdt, Lene M.; Kohrt, Jens S.; Larsen, Kim S.; Pedersen, Morten M.; Wøhlk, Sanne (2006-10-11). "The maximum resource bin packing problem". Theoretical Computer Science. 362 (1): 127–139. doi:10.1016/j.tcs.2006.06.001. ISSN   0304-3975.
  52. Huang, Xin; Lu, Pinyan (2020-11-10). "An Algorithmic Framework for Approximating Maximin Share Allocation of Chores". arXiv: 1907.04505 [cs.GT].
  53. Ma, Ruixin; Dósa, György; Han, Xin; Ting, Hing-Fung; Ye, Deshi; Zhang, Yong (2013-08-01). "A note on a selfish bin packing problem". Journal of Global Optimization. 56 (4): 1457–1462. doi:10.1007/s10898-012-9856-9. ISSN   0925-5001. S2CID   3082040.
  54. 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
  55. Optimizing Three-Dimensional Bin Packing Through Simulation
  56. 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.