|
|
| (One intermediate revision by one other user not shown) |
| Line 1: |
Line 1: |
| {{Redirect|BKP}}
| | The Bed Bath and Beyond Gift certificate are gift cards that you can send to your friends and relations for all occasions, be it weddings, Christmas, house warming parties, birthdays while.<br><br>School stationery is the crucial element in student life. Now in this fast growing age school stationery one more increase ordinarilly. Most of the fogeys are too worried whether they have to buy school stationery items. Regular children's are demanding issues for their residence work or projects. It is too much pressure on parents to take market daily for stationery purchasing. It takes too much time to look at shopping. Schools study pattern is also changed down to the current trend, so the stationery becomes important to undertake projects as well as for study. Now kids are conscious regarding study to ensure that they always need good study material. They never desire to compromise with any process.<br><br><br><br>Newport oval Gold mirror is ovular shaped mirror which may be as a role home decoration that is known due to the fact wooden edges with modern finishing wearing it. The price range of this mirror is $22. Newport oval silver mirror from the of its kinds and also highly included in the space of dwelling. The unique factor on the mirror is its highly reflecting nature which brings a associated with brightness for the room in reflecting photo of home.<br><br>If jazz music and Cajun food are superior thoughts that enter head when New Orleans is mentioned, it'll be good if various products they in addition have their distinct style home based decor. The dining in this state features bowls, utensils and plates that are decorated with seafood. So, you must also make positive your utensils have seafoods drawn built in if market . the New Orleans theme at your residence.<br><br>This involving method is tremendously typical for just about any greenhouse, and out if the area weather encourages. It also will work fantastic on the floor coverings. An benefit of an indoor aquaponics process could be the power to manage the climate. When outdoors, the weather conditions will ascertain when and what you can grow. But inside, you control the temperature and eradicate prevalent garden pest infestations. No much more slugs, snails, gophers, weeds or any people things which get the exciting out of gardening Backyard Aquaponics it.<br><br>Paint colors can be near on impossible to choose sometimes. Where possible stick with neutral colors if you want to have lots of color in other places in the area. If you have neutral furniture is definitely the to try using a warm hue. Bright colors looks fantastic on walls also however individuals enjoys these. Just remember when you are applying your paint colors; you have pick something that you enjoy. You wouldn't like to need to spend extra time and money repainting basic or worse, be stuck with a color that you hate!<br><br>Now, take a similar 'knock off' and refill your business name brand plastic box. Voila! No one will ever know improbable afford to maintain with the Joneses. Who aspires to keep up with them anyway? I heard they go broke financing the fuel in that H3!<br><br>Maybe, your friend or special someone will celebrate their birthday parties. So, instead of investing in a jewelry or have an internationally tour, just settle to a portrait that sports his pooch. This present is more meaningful towards recipient especially if he is a pet companion.<br><br>If you loved this write-up and you would like to receive more information with regards to [http://mohamedia.net/ Decorate your home] kindly take a look at our website. |
| [[File:Knapsack.svg|thumb|right|250px|Example of a one-dimensional (constraint) knapsack problem: which boxes should be chosen to maximize the amount of money while still keeping the overall weight under or equal to 15 kg? A [[List of knapsack problems#Multiple constraints|multiple constrained problem]] could consider both the weight and volume of the boxes. <br />
| |
| (Solution: if any number of each box is available, then three yellow boxes and three grey boxes; if only the shown boxes are available, then all but the green box.)]]
| |
| | |
| The '''knapsack problem''' or '''rucksack problem''' is a problem in [[combinatorial optimization]]: Given a set of items, each with a mass and a value, determine the number of each item to include in a collection so that the total weight is less than or equal to a given limit and the total value is as large as possible. It derives its name from the problem faced by someone who is constrained by a fixed-size [[knapsack]] and must fill it with the most valuable items.
| |
| | |
| The problem often arises in [[resource allocation]] where there are financial constraints and is studied in fields such as [[combinatorics]], [[computer science]], [[computational complexity theory|complexity theory]], [[cryptography]] and [[applied mathematics]].
| |
| | |
| The knapsack problem has been studied for more than a century, with early works dating as far back as 1897.<ref>{{cite journal | title = On the partition of numbers | author = Mathews, G. B. | journal = Proceedings of the London Mathematical Society | volume = 28 | pages = 486–490 | date = 25 June 1897 | url = http://plms.oxfordjournals.org/content/s1-28/1/486.full.pdf}}</ref> It is not known how the name "knapsack problem" originated, though the problem was referred to as such in the early works of mathematician [[Tobias Dantzig]] (1884–1956),<ref>Dantzig, Tobias. Numbers: The Language of Science, 1930.</ref> suggesting that the name could have existed in folklore before a mathematical problem had been fully defined.<ref>Kellerer, Pferschy, and Pisinger 2004, p. 3</ref>
| |
| | |
| ==Applications==
| |
| A 1998 study of the [http://www.cs.sunysb.edu/~algorith/ Stony Brook University Algorithm Repository] showed that, out of 75 algorithmic problems, the knapsack problem was the 18th most popular and the 4th most needed after [[kd-tree]]s, [[suffix tree]]s, and the [[bin packing problem]].<ref>{{cite journal | title = Who is Interested in Algorithms and Why? Lessons from the Stony Brook Algorithm Repository | author = Skiena, S. S. |journal = AGM SIGACT News | volume = 30 | issue=3 |date = September 1999| pages= 65–74 |ISSN=0163-5700 |url = http://delivery.acm.org/10.1145/340000/333627/p65-skiena.pdf?key1=333627&key2=9434996821&coll=GUIDE&dl=GUIDE&CFID=108583297&CFTOKEN=90100478}}</ref>
| |
| | |
| Knapsack problems appear in real-world decision-making processes in a wide variety of fields, such as finding the least wasteful way to cut raw materials,<ref>Kellerer, Pferschy, and Pisinger 2004, p. 449</ref> seating contest of [[investment]]s and [[Portfolio (finance)|portfolios]],<ref>Kellerer, Pferschy, and Pisinger 2004, p. 461</ref> seating contest of assets for [[Securitization|asset-backed securitization]],<ref>Kellerer, Pferschy, and Pisinger 2004, p. 465</ref> and generating keys for the [[Merkle–Hellman knapsack cryptosystem]].<ref>Kellerer, Pferschy, and Pisinger 2004, p. 472</ref>
| |
| | |
| One early application of knapsack algorithms was in the construction and scoring of tests in which the test-takers have a choice as to which questions they answer. For small examples it is a fairly simple process to provide the test-takers with such a choice. For example, if an exam contains 12 questions each worth 10 points, the test-taker need only answer 10 questions to achieve a maximum possible score of 100 points. However, on tests with a heterogeneous distribution of point values—i.e. different questions are worth different point values— it is more difficult to provide choices. Feuerman and Weiss proposed a system in which students are given a heterogeneous test with a total of 125 possible points. The students are asked to answer all of the questions to the best of their abilities. Of the possible subsets of problems whose total point values add up to 100, a knapsack algorithm would determine which subset gives each student the highest possible score.<ref>{{cite journal | title = A Mathematical Programming Model for Test Construction and Scoring | journal = Management Science | volume = 19 | issue = 8 |date = April 1973|pages = 961–966 | author = Feuerman, Martin; Weiss, Harvey | jstor = 2629127}}</ref>
| |
| | |
| == Definition ==
| |
| The most common problem being solved is the '''0-1 knapsack problem''', which restricts the number ''x<sub>i</sub>'' of copies of each kind of item
| |
| to zero or one.
| |
| | |
| Mathematically the 0-1-knapsack problem can be formulated as:
| |
| | |
| Let there be <math>n</math> items, <math>z_1</math> to <math>z_n</math> where <math>z_i</math> has a value <math>v_i</math> and weight <math>w_i</math>.
| |
| The maximum weight that we can carry in the bag is ''W''.
| |
| It is common to assume that all values and weights are nonnegative. To simplify the representation, we also assume that the items are listed in increasing order of weight.
| |
| | |
| *Maximize <math>\qquad \sum_{i=1}^n v_ix_i</math> subject to <math>\qquad \sum_{i=1}^n w_ix_i \leqslant W, \quad \quad x_i \in \{0,1\}</math>
| |
| Maximize the sum of the values of the items in the knapsack so that the sum of the weights must be less than the knapsack's capacity.
| |
| | |
| The '''bounded knapsack problem''' ('''BKP''') removes the restriction that there is only one of each item, but restricts the number <math>x_i</math> of copies of
| |
| each kind of item to an integer value <math>c_i</math>.
| |
| | |
| Mathematically the bounded knapsack problem can be formulated as:
| |
| *Maximize <math>\qquad \sum_{i=1}^n v_ix_i</math> subject to <math>\qquad \sum_{i=1}^n w_ix_i \leqslant W, \quad \quad x_i \in \{0,1,\ldots,c_i\}</math>
| |
| | |
| The '''unbounded knapsack problem''' ('''UKP''') places no upper bound on the number of copies of each kind of item and can be formulated as above except for that the only restriction on <math>x_i</math> is that it is a non-negative integer. If the example with the colored bricks above is viewed as an unbounded knapsack problem, then the solution is to take three yellow boxes and three grey boxes.
| |
| | |
| == Computational complexity ==
| |
| The knapsack problem is interesting from the perspective of computer science for many reasons:
| |
| * The [[decision problem]] form of the knapsack problem (''Can a value of at least ''V'' be achieved without exceeding the weight ''W''?'') is [[NP-complete]], thus there is no possible algorithm both correct and fast (polynomial-time) on all cases, unless [[P versus NP problem|P=NP]].
| |
| * While the decision problem is NP-complete, the optimization problem is [[NP-hard]], its resolution is at least as difficult as the decision problem, and there is no known polynomial algorithm which can tell, given a solution, whether it is optimal (which would mean that there is no solution with a larger, thus solving the decision problem NP-complete).
| |
| * There is a [[pseudo-polynomial time]] algorithm using [[dynamic programming]].
| |
| * There is a [[FPTAS|fully polynomial-time approximation scheme]], which uses the pseudo-polynomial time algorithm as a subroutine, described below.
| |
| * Many cases that arise in practice, and "random instances" from some distributions, can nonetheless be solved exactly.
| |
| | |
| There is a link between the "decision" and "optimization" problems in that if there exists a polynomial algorithm that solves the "decision" problem, then one can find the maximum value for the optimization problem in polynomial time by applying this algorithm iteratively while increasing the value of k . On the other hand, if an algorithm finds the optimal value of optimization problem in polynomial time, then the decision problem can be solved in polynomial time by comparing the value of the solution output by this algorithm with the value of k . Thus, both versions of the problem are of similar difficulty.
| |
| | |
| One theme in research literature is to identify what the "hard" instances of the knapsack problem look like,<ref name="pisinger200308">Pisinger, D. 2003. Where are the hard knapsack problems? Technical Report 2003/08, Department of Computer Science, University of Copenhagen, Copenhagen, Denmark.</ref><ref name="Cacetta2001">
| |
| L. Caccetta, A. Kulanoot, Computational Aspects of Hard Knapsack Problems,
| |
| Nonlinear Analysis 47 (2001) 5547–5558.</ref> or viewed another way, to identify what properties of instances in practice might make them more amenable than their worst-case NP-complete behaviour suggests.<ref
| |
| name ="poirriez et all 2009">Vincent Poirriez, Nicola Yanev, Rumen Andonov (2009) A Hybrid Algorithm for the Unbounded Knapsack Problem Discrete Optimization http://dx.doi.org/10.1016/j.disopt.2008.09.004</ref> The goal in finding these "hard" instances is for their use in [[public key cryptography]] systems, such as the [[Merkle-Hellman knapsack cryptosystem]].
| |
| | |
| == Solving ==
| |
| Several algorithms are freely available to solve knapsack problems, based on dynamic programming approach,<ref name="eduk2000">Rumen Andonov, Vincent Poirriez, Sanjay Rajopadhye (2000) Unbounded Knapsack Problem : dynamic programming revisited European Journal of Operational Research 123: 2. 168–181 http://dx.doi.org/10.1016/S0377-2217(99)00265-9
| |
| </ref> branch and bound approach<ref name="martellototh90">S. Martello, P. Toth, Knapsack Problems: Algorithms and Computer Implementation,
| |
| John Wiley and Sons, 1990</ref> or [[hybrid algorithm|hybridizations]] of both approaches.<ref name="poirriez et all 2009"/><ref
| |
| name="martellopisingertoth99a">S. Martello, D. Pisinger, P. Toth, Dynamic programming and strong bounds for the 0-1
| |
| knapsack problem, ''Manag. Sci.'', 45:414–424, 1999.</ref><ref
| |
| name="plateau85">G. Plateau, M. Elkihel, A hybrid algorithm for the 0-1 knapsack problem, ''Methods of
| |
| Oper. Res.'', 49:277–293, 1985.</ref><ref name="martellotothe99">S. Martello, P. Toth, A mixture of dynamic programming and branch-and-bound for the subset-sum problem, ''Manag. Sci.'', 30:765–771</ref>
| |
| | |
| === Dynamic programming ===
| |
| | |
| ==== Unbounded knapsack problem ====
| |
| If all weights (<math>w_1,\ldots,w_n</math>) are
| |
| nonnegative integers, the knapsack problem can be solved in [[pseudo-polynomial time]] using [[dynamic programming]]. The following describes a dynamic programming solution for the ''unbounded'' knapsack problem.
| |
| | |
| To simplify things, assume all weights are strictly positive (''w<sub>i</sub>'' > 0). We wish to maximize total value subject to the constraint that total weight is less than or equal to ''W''. Then for each ''w'' ≤ ''W'', define ''m[w]'' to be the maximum value that can be attained with total weight less than or equal to ''w''. ''m[W]'' then is the solution to the problem.
| |
| | |
| Observe that ''m[w]'' has the following properties:
| |
| | |
| * <math>m[0]=0\,\!</math> (the sum of zero items, i.e., the summation of the empty set)
| |
| * <math>m[w]= \max_{w_i \le w}(v_i+m[w-w_i])</math>
| |
| where <math>v_i</math> is the value of the ''i''-th kind of item.
| |
| | |
| (To formulate the equation above, the idea used is that the solution for a knapsack is the same as the value of one correct item plus the solution for a knapsack with smaller capacity, specifically one with the capacity reduced by the weight of that chosen item.)
| |
| | |
| Here the maximum of the empty set is taken to be zero. Tabulating the results from <math>m[0]</math> up through <math>m[W]</math> gives the solution. Since the calculation of each <math>m[w]</math> involves examining <math>n</math> items, and there are <math>W</math> values of <math>m[w]</math> to calculate, the running time of the dynamic programming solution is [[Big O notation|<math>O(nW)</math>]]. Dividing <math>w_1,\,w_2,\,\ldots,\,w_n,\,W</math> by their [[greatest common divisor]] is an obvious way to improve the running time.
| |
| | |
| The <math>O(nW)</math> complexity does not contradict the fact that the knapsack problem is [[NP-complete]], since <math>W</math>, unlike <math>n</math>, is not polynomial in the length of the input to the problem. The length of the <math>W</math> input to the problem is proportional to the number of bits in <math>W</math>, <math>\log W</math>, not to <math>W</math> itself.
| |
| | |
| ==== 0/1 Knapsack Problem ====
| |
| A similar dynamic programming solution for the 0/1 knapsack problem also runs in pseudo-polynomial time. Assume <math>w_1,\,w_2,\,\ldots,\,w_n,\,W</math> are strictly positive integers. Define <math>m[i,w]</math> to be the maximum value that can be attained with weight less than or equal to <math>w</math> using items up to <math>i</math>.
| |
| | |
| We can define <math>m[i,w]</math> recursively as follows:
| |
| | |
| * <math>m[i,\,w]=m[i-1,\,w]</math> if <math>w_i > w\,\!</math> (the new item is more than the current weight limit)
| |
| * <math>m[i,\,w]=\max(m[i-1,\,w],\,m[i-1,w-w_i]+v_i)</math> if <math>w_i \leqslant w</math>.
| |
| | |
| The solution can then be found by calculating <math>m[n,W]</math>. To do this efficiently we can use a table to store previous computations.
| |
| | |
| The following is pseudo code for the dynamic program:
| |
| | |
| // Input:
| |
| // Values (stored in array v)
| |
| // Weights (stored in array w)
| |
| // Number of distinct items (n)
| |
| // Knapsack capacity (W)
| |
| for j from 0 to W do
| |
| m[0, j] := 0
| |
| end for
| |
| for i from 1 to n do
| |
| for j from 0 to W do
| |
| if w[i] <= j then
| |
| m[i, j] := max(m[i-1, j], m[i-1, j-w[i]<nowiki></nowiki>] + v[i])
| |
| else
| |
| m[i, j] := m[i-1, j]
| |
| end if
| |
| end for
| |
| end for
| |
| | |
| This solution will therefore run in <math>O(nW)</math> time and <math>O(nW)</math> space. Additionally, if we use only a 1-dimensional array <math>m[w]</math> to store the current optimal values and pass over this array <math>i+1</math> times, rewriting from <math>m[W]</math> to <math>m[1]</math> every time, we get the same result for only <math>O(W)</math> space.
| |
| | |
| === Meet-in-the-middle ===
| |
| Another algorithm for 0-1 knapsack, discovered in 1974 <ref>{{citation
| |
| | last1 = Horowitz | first1 = Ellis
| |
| | last2 = Sahni | first2 = Sartaj | author2-link = Sartaj Sahni
| |
| | doi = 10.1145/321812.321823
| |
| | journal = Journal of the Association for Computing Machinery
| |
| | mr = 0354006
| |
| | pages = 277–292
| |
| | title = Computing partitions with applications to the knapsack problem
| |
| | volume = 21
| |
| | year = 1974}}</ref> and sometimes called "meet-in-the-middle" due to parallels to [[Meet-in-the-middle attack|a similarly named algorithm in cryptography]], is exponential in the number of different items but may be preferable to the DP algorithm when <math>W</math> is large compared to n. In particular, if the <math>w_i</math> are nonnegative but not integers, we could still use the dynamic programming algorithm by scaling and rounding (i.e. using [[fixed-point arithmetic]]), but if the problem requires <math>d</math> fractional digits of precision to arrive at the correct answer, <math>W</math> will need to be scaled by <math>10^d</math>, and the DP algorithm will require <math>O(W*10^d)</math> space and <math>O(nW*10^d)</math> time.
| |
| | |
| :'' Meet-in-the-middle algorithm
| |
| | |
| '''input:'''
| |
| a set of items with weights and values
| |
| '''output:'''
| |
| the greatest combined value of a subset
| |
| partition the set {1...n} into two sets A and B of approximately equal size
| |
| compute the weights and values of all subsets of each set
| |
| '''for''' each subset of A
| |
| find the subset of B of greatest value such that the combined weight is less than W
| |
| keep track of the greatest combined value seen so far
| |
| | |
| The algorithm takes <math>O(2^{n/2})</math> space, and efficient implementations of step 3 (for instance, sorting the subsets of B by weight, discarding subsets of B which weigh more than other subsets of B of greater or equal value, and using binary search to find the best match) result in a runtime of <math>O(n*2^{n/2})</math>. As with the [[Meet-in-the-middle attack|meet in the middle attack]] in cryptography, this improves on the <math>O(n*2^n)</math> runtime of a naive brute force approach (examining all subsets of {1...n}), at the cost of using exponential rather than constant space (see also [[baby-step giant-step]]).
| |
| | |
| === Approximation algorithms ===
| |
| As for most NP-complete problems, it may be enough to find workable solutions even if they are not optimal. Preferably, however, the approximation comes with a guarantee on the difference between the value of the solution found and the value of the optimal solution.
| |
| | |
| As with many useful but computationally complex algorithms, there has been substantial research on creating and analyzing algorithms that approximate a solution. The knapsack problem, though NP-Hard, is one of a collection of algorithms that can still be approximated to any specified degree. This means that the problem has a polynomial time approximation scheme. To be exact, the knapsack problem has a fully polynomial time approximation scheme (FPTAS).<ref name="Vazirani, Vijay 2003">Vazirani, Vijay. Approximation Algorithms. Springer-Verlag Berlin Heidelberg, 2003.</ref>
| |
| | |
| ==== Greedy approximation algorithm ====
| |
| [[George Dantzig]] proposed a [[greedy algorithm|greedy]] [[approximation algorithm]] to solve the unbounded knapsack problem.<ref name="dantzig1957">[[George Dantzig|George B. Dantzig]], Discrete-Variable Extremum Problems, Operations Research
| |
| Vol. 5, No. 2, April 1957, pp. 266–288, {{DOI|10.1287/opre.5.2.266}}</ref> His version sorts the items in decreasing order of value per unit of weight, <math>v_i/w_i</math>. It then proceeds to insert them into the sack, starting with as many copies as possible of the first kind of item until there is no longer space in the sack for more. Provided that there is an unlimited supply of each kind of item, if <math>m</math> is the maximum value of items that fit into the sack, then the greedy algorithm is guaranteed to achieve at least a value of <math>m/2</math>. However, for the bounded problem, where the supply of each kind of item is limited, the algorithm may be far from optimal.
| |
| | |
| ==== Fully polynomial time approximation scheme ====
| |
| The [[fully polynomial time approximation scheme]] (FPTAS) for the knapsack problem takes advantage of the fact that the reason the problem has no polynomial time solutions is because the profits associated with the items are not restricted. If one rounds off some of the least significant digits of the profit values then they will be bounded by a polynomial and 1/ε where ε is a bound on the correctness of the solution. This restriction then means that an algorithm can find a solution in polynomial time that is correct within(1-ε) percent of the optimal solution.<ref name="Vazirani, Vijay 2003"/>
| |
| | |
| :'' An Algorithm for FPTAS
| |
| | |
| '''input''':
| |
| ε∈[0,1],
| |
| a list, A, of n items their values, <math>a_i</math>, and weights
| |
| '''output''': S' the FPTAS solution
| |
| K := εP/n where P=v_i where item i is the highest valued item
| |
| '''for''' <math>a_i</math> '''from''' 1 '''to''' n
| |
| profit'(<math>a_i</math>) = ⌊profit(<math>a_i</math>)/ K⌋
| |
| '''return''' the solution, S', using the profit' values in the dynamic program outlined above
| |
| | |
| '''Theorem:''' The set, S', output by the algorithm above satisfies:
| |
| | |
| profit(S') ≥ (1-ε)* profit(S*)
| |
| | |
| Where S' is the solution produced by the algorithm and S* is the optimal solution.
| |
| | |
| ===Dominance relations===
| |
| Solving the unbounded knapsack problem can be made easier by throwing away items which will never be needed. For a given item ''i'', suppose we could find a set of items ''J'' such that their total weight is less than the weight of ''i'', and their total value is greater than the value of ''i''. Then ''i'' cannot appear in the optimal solution, because we could always improve any potential solution containing ''i'' by replacing ''i'' with the set ''J''. Therefore we can disregard the ''i''-th item altogether. In such cases, ''J'' is said to '''dominate''' ''i''. (Note that this does not apply to bounded knapsack problems, since we may have already used up the items in ''J''.)
| |
| | |
| Finding dominance relations allows us to significantly reduce the size of the search space. There are several different types of [[dominance relations]],<ref
| |
| name ="poirriez et all 2009">Vincent Poirriez, Nicola Yanev, Rumen Andonov (2009) A Hybrid Algorithm for the Unbounded Knapsack Problem, section 2: Discrete Optimization http://dx.doi.org/10.1016/j.disopt.2008.09.004</ref> which all satisfy an inequality of the form:
| |
| | |
| <math>\qquad \sum_{j \in J} w_j\,x_j \ \le \alpha\,w_i</math>, and <math>\qquad \sum_{j \in J} v_j\,x_j \ \ge \alpha\,v_i\,</math> for some <math>x \in Z _+^n </math>
| |
| | |
| where
| |
| <math>\alpha\in Z_+ \,,J\subseteq N</math> and <math>i\not\in J</math>. The vector <math>x</math> denotes the number of copies of each member of ''J''.
| |
| | |
| ;Collective dominance: The ''i''-th item is '''collectively dominated''' by ''J'', written as <math>i\ll J</math>, if the total weight of some combination of items in ''J'' is less than ''w<sub>i</sub>'' and their total value is greater than ''v<sub>i</sub>''. Formally, <math>\qquad \sum_{j \in J} w_j\,x_j \ \le w_i</math> and <math>\qquad \sum_{j \in J} v_j\,x_j \ \ge v_i</math> for some <math>x \in Z _+^n </math>, i.e. <math>\alpha=1</math>. Verifying this dominance is computationally hard, so it can only be used with a dynamic programming approach. In fact, this is equivalent to solving a smaller knapsack decision problem where2 ''V'' = ''v<sub>i</sub>'', ''W'' = ''w<sub>i</sub>'', and the items are restricted to ''J''.
| |
| ;Threshold dominance: The ''i''-th item is '''threshold dominated''' by ''J'', written as <math>i\prec\prec J</math>, if some number of copies of ''i'' are dominated by ''J''. Formally, <math>\qquad \sum_{j \in J} w_j\,x_j \ \le \alpha\,w_i</math>, and <math>\qquad \sum_{j \in J} v_j\,x_j \ \ge \alpha\,v_i\,</math> for some <math>x \in Z _+^n </math> and <math>\alpha\geq 1</math>. This is a generalization of collective dominance, first introduced in<ref name="eduk2000"/> and used in the EDUK algorithm. The smallest such <math>\alpha</math> defines the '''threshold''' of the item ''i'', written <math>t_i =(\alpha-1)w_i</math>. In this case, the optimal solution could contain at most <math>\alpha-1</math> copies of ''i''.
| |
| ;Multiple dominance: The ''i''-th item is '''multiply dominated''' by a single item ''j'', written as <math>i\ll_{m} j</math>, if ''i'' is dominated by some number of copies of ''j''. Formally, <math>\qquad w_j\,x_j \ \le w_i</math>, and <math>\qquad v_j\,x_j \ \ge v_i</math> for some <math>x_j \in Z _+ </math> i.e. <math> J=\{j\}, \alpha=1, x_j=\lfloor \frac{w_i}{w_j}\rfloor</math>. This dominance could be efficiently used during preprocessing because it can be detected relatively easily.
| |
| ;Modular dominance: Let ''b'' be the ''best item'', i.e. <math>\frac{v_b}{w_b}\ge\frac{v_i}{w_i}\, </math> for all ''i''. This is the item with the greatest density of value. The ''i''-th item is '''modularly dominated''' by a single item ''j'', written as <math>i\ll_\equiv j</math>, if ''i'' is dominated by ''j'' plus several copies of ''b''. Formally, <math> w_j+tw_b \le w_i</math>, and <math>v_j +tv_b \ge v_i </math> i.e. <math>J=\{b,j\}, \alpha=1, x_b=t, x_j=1</math>.
| |
| | |
| ==Solutions==
| |
| | |
| ===Lua===
| |
| | |
| Recursive Lua Knapsack solution
| |
| <source lang="lua">
| |
| values = {1, 2, 3, 4, 5, 6, 7, 8, 9};
| |
| inSack = {}
| |
| total = 0;
| |
| function knapsack(i, weight)
| |
| if weight == 0 then
| |
| print("Success The following combination is in the knapsack:");
| |
| for i = 1, #inSack do
| |
| total = total + inSack[i];
| |
| print(inSack[i]);
| |
| end
| |
| print("Totaling to Input of: "..total)
| |
| return
| |
| elseif i <= 0 then
| |
| print("Sorry your weight combination, is not possible with the current values ");
| |
| return;
| |
| end
| |
| if values[i] > weight then
| |
| return knapsack(i-1, weight);
| |
| else
| |
| inSack[#inSack + 1] = values[i];
| |
| return knapsack(i-1, weight - values[i]);
| |
| end
| |
|
| |
| end
| |
| -- Waits for user input to terminal
| |
| local number = io.read()
| |
| knapsack(#values, tonumber(number));
| |
| </source>
| |
| | |
| ===C#===
| |
| | |
| <source lang="csharp">
| |
| using System;
| |
| using System.Collections.Generic;
| |
| using System.Linq;
| |
| | |
| namespace Tests_With_Framework_4
| |
| {
| |
|
| |
| class Bag : IEnumerable<Bag.Item>
| |
| {
| |
| List<Item> items;
| |
| const int MaxWeightAllowed = 400;
| |
|
| |
| public Bag()
| |
| {
| |
| items = new List<Item>();
| |
| }
| |
|
| |
| void AddItem(Item i)
| |
| {
| |
| if ((TotalWeight + i.Weight) < MaxWeightAllowed)
| |
| items.Add(i);
| |
| }
| |
|
| |
| public void Calculate(List<Item> items)
| |
| {
| |
| foreach (Item i in Sorte(items))
| |
| {
| |
| AddItem(i);
| |
| }
| |
| }
| |
|
| |
| List<Item> Sorte(List<Item> inputItems)
| |
| {
| |
| List<Item> choosenItems = new List<Item>();
| |
| for (int i = 0; i < inputItems.Count; i++)
| |
| {
| |
| int j = -1;
| |
| if (i == 0)
| |
| {
| |
| choosenItems.Add(inputItems[i]);
| |
| }
| |
| if (i > 0)
| |
| {
| |
| if (!RecursiveF(inputItems, choosenItems, i, choosenItems.Count - 1,
| |
| false, ref j))
| |
| {
| |
| choosenItems.Add(inputItems[i]);
| |
| }
| |
| }
| |
| }
| |
| return choosenItems;
| |
| }
| |
|
| |
| bool RecursiveF(List<Item> knapsackItems, List<Item> choosenItems, int i,
| |
| int lastBound, bool dec, ref int indxToAdd)
| |
| {
| |
| if (!(lastBound < 0))
| |
| {
| |
| if ( knapsackItems[i].ResultWV < choosenItems[lastBound].ResultWV )
| |
| {
| |
| indxToAdd = lastBound;
| |
| }
| |
| return RecursiveF(knapsackItems, choosenItems, i, lastBound - 1, true, ref indxToAdd);
| |
| }
| |
| if (indxToAdd > -1)
| |
| {
| |
| choosenItems.Insert(indxToAdd, knapsackItems[i]);
| |
| return true;
| |
| }
| |
| return false;
| |
| }
| |
|
| |
| #region IEnumerable<Item> Members
| |
| IEnumerator<Item> IEnumerable<Item>.GetEnumerator()
| |
| {
| |
| foreach (Item i in items)
| |
| yield return i;
| |
| }
| |
| #endregion
| |
|
| |
| #region IEnumerable Members
| |
| System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
| |
| {
| |
| return items.GetEnumerator();
| |
| }
| |
| #endregion
| |
|
| |
| public int TotalWeight
| |
| {
| |
| get
| |
| {
| |
| var sum = 0;
| |
| foreach (Item i in this)
| |
| {
| |
| sum += i.Weight;
| |
| }
| |
| return sum;
| |
| }
| |
| }
| |
|
| |
| public class Item
| |
| {
| |
| public string Name { get; set; }
| |
| public int Weight { get; set; }
| |
| public int Value { get; set; }
| |
| public int ResultWV { get { return Weight-Value; } }
| |
| public override string ToString()
| |
| {
| |
| return "Name : " + Name + " Wieght : " + Weight +
| |
| " Value : " + Value + " ResultWV : " + ResultWV;
| |
| }
| |
| }
| |
| }
| |
|
| |
| class Program
| |
| {
| |
| static void Main(string[] args)
| |
| {List<Bag.Item> knapsackItems = new List<Bag.Item>();
| |
| knapsackItems.Add(new Bag.Item() { Name = "Map", Weight = 9, Value = 150 });
| |
| knapsackItems.Add(new Bag.Item() { Name = "Water", Weight = 153, Value = 200 });
| |
| knapsackItems.Add(new Bag.Item() { Name = "Compass", Weight = 13, Value = 35 });
| |
| knapsackItems.Add(new Bag.Item() { Name = "Sandwitch", Weight = 50, Value = 160 });
| |
| knapsackItems.Add(new Bag.Item() { Name = "Glucose", Weight = 15, Value = 60 });
| |
| knapsackItems.Add(new Bag.Item() { Name = "Tin", Weight = 68, Value = 45 });
| |
| knapsackItems.Add(new Bag.Item() { Name = "Banana", Weight = 27, Value = 60 });
| |
| knapsackItems.Add(new Bag.Item() { Name = "Apple", Weight = 39, Value = 40 });
| |
| knapsackItems.Add(new Bag.Item() { Name = "Cheese", Weight = 23, Value = 30 });
| |
| knapsackItems.Add(new Bag.Item() { Name = "Beer", Weight = 52, Value = 10 });
| |
| knapsackItems.Add(new Bag.Item() { Name = "Suntan Cream", Weight = 11, Value = 70 });
| |
| knapsackItems.Add(new Bag.Item() { Name = "Camera", Weight = 32, Value = 30 });
| |
| knapsackItems.Add(new Bag.Item() { Name = "T-shirt", Weight = 24, Value = 15 });
| |
| knapsackItems.Add(new Bag.Item() { Name = "Trousers", Weight = 48, Value = 10 });
| |
| knapsackItems.Add(new Bag.Item() { Name = "Umbrella", Weight = 73, Value = 40 });
| |
| knapsackItems.Add(new Bag.Item() { Name = "WaterProof Trousers", Weight = 42, Value = 70 });
| |
| knapsackItems.Add(new Bag.Item() { Name = "Note-Case", Weight = 22, Value = 80 });
| |
| knapsackItems.Add(new Bag.Item() { Name = "Sunglasses", Weight = 7, Value = 20 });
| |
| knapsackItems.Add(new Bag.Item() { Name = "Towel", Weight = 18, Value = 12 });
| |
| knapsackItems.Add(new Bag.Item() { Name = "Socks", Weight = 4, Value = 50 });
| |
| knapsackItems.Add(new Bag.Item() { Name = "Book", Weight = 30, Value = 10 });
| |
| knapsackItems.Add(new Bag.Item() { Name = "waterproof overclothes ", Weight = 43, Value = 75 });
| |
|
| |
| Bag b = new Bag();
| |
| b.Calculate(knapsackItems);
| |
| b.All(x => { Console.WriteLine(x); return true; });
| |
| Console.WriteLine(b.Sum(x => x.Weight));
| |
| Console.ReadKey();
| |
| }
| |
| }
| |
| }
| |
| </source>
| |
| | |
| == Variations ==
| |
| There are many variations of the knapsack problem that have arisen from the vast number of applications of the basic problem. The main variations occur by changing the number of some problem parameter such as the number of items, number of objectives, or even the number of knapsacks.
| |
| | |
| ===Multi-objective knapsack problem===
| |
| This variation changes the goal of the individual filling the knapsack. Instead of one objective, such as maximizing the monetary profit, the objective could have several dimensions. For example there could be environmental or social concerns as well as economic goals. Problems frequently addressed include portfolio and transportation logistics optimizations <ref>Chang, T. J., et al. Heuristics for Cardinality Constrained Portfolio Optimization.
| |
| Technical Report, London SW7 2AZ, England: The Management School, Imperial
| |
| College, May 1998</ref><ref>Chang, C. S., et al. "Genetic Algorithm Based Bicriterion Optimization for Traction
| |
| Substations in DC Railway System." In Fogel [102], 11-16.</ref>
| |
| | |
| As a concrete example, suppose you ran a cruise ship. You have to decide how many famous comedians to hire. This boat can handle no more than one ton of passengers and the entertainers must weigh less than 1000 lbs. Each comedian has a weight, brings in business based on their popularity and asks for a specific salary. In this example you have multiple objectives. You want, of course, to maximize the popularity of your entertainers while minimizing their salaries. Also, you want to have as many entertainers as possible.
| |
| | |
| ===Multiple knapsack problem===
| |
| This variation is similar to the [[Bin packing problem|Bin Packing Problem]]. It differs from the Bin Packing Problem that a subset of items can be selected, whereas, in the Bin Packing Problem, all items have to be packed to certain bins. The concept is that there are multiple knapsacks. This may seem a trivial change, but it is not equivalent to adding to the capacity of the initial knapsack. This variation is used in many loading and scheduling problems in Operations Research and has a [[Polynomial-time approximation scheme|PTAS]]<ref>Chandra Chekuri and Sanjeev Khanna. 2000. A PTAS for the multiple knapsack problem. In Proceedings of the eleventh annual ACM-SIAM symposium on Discrete algorithms (SODA '00). Society for Industrial and Applied Mathematics, Philadelphia, PA, USA, 213-222.</ref>
| |
| | |
| ===Quadratic knapsack problem===
| |
| As described by Wu et al.:
| |
| <blockquote> | |
| The quadratic knapsack problem (QKP) maximizes a quadratic objective function subject to a binary and linear capacity constraint.<ref name=QKP>{{cite journal | title = Global Optimality Conditions and Optimization Methods for Quadratic Knapsack Problems | author = Wu, Z. Y.; Yang, Y. J.;Bai, F. S.;Mammadov, M.| journal = J Optim Theory Appl | year = 2011 | volume = 151 | pages = 241–259 | doi = 10.1007/s10957-011-9885-4 | url = http://link.springer.com/article/10.1007/s10957-011-9885-4}}</ref>
| |
| </blockquote>
| |
| The quadratic knapsack problem was discussed under that title by Gallo, Hammer, and Simeone in 1980.<ref>{{cite journal | title = Quadratic knapsack problems | author = Gallo, G.; Hammer, P. L.; Simeone, B. | journal = Mathematical Programming Studies | year = 1980 | volume = 12 | pages = 132–149 | doi = 10.1007/BFb0120892 | url = http://www.springerlink.com/content/x804231403086x51/}}</ref> However, Gallo and Simeone<ref>{{cite journal | title = On the Supermodular Knapsack Problem | author = Gallo, G.; Simeone, B. | journal = Mathematical Programming Studies | year = 1988 | volume = 45 | pages = 295–309 | publisher = North-Holland | url = http://link.springer.com/article/10.1007%2FBF01589108?LI=true#page-1}}</ref> attribute the first treatment of the problem to Witzgall<ref>{{cite book | title = Mathematical methods of site seating contest for Electronic Message Systems (EMS) | author = Witzgall, C. | publisher = NBS Internal report | year = 1975}}</ref> in 1975.
| |
| | |
| ===Subset-sum problem===
| |
| The [[subset sum problem]], is a special case of the decision and '''0-1''' problems where each kind of item, the weight equals the value: <math>w_i=v_i</math>. In the field of [[cryptography]], the term ''knapsack problem'' is often used to refer specifically to the subset sum problem and is commonly known as one of [[Karp's 21 NP-complete problems]].<ref>Richard M. Karp (1972). "Reducibility Among Combinatorial Problems". In R. E. Miller and J. W. Thatcher (editors). Complexity of Computer Computations. New York: Plenum. pp. 85–103</ref>
| |
| | |
| The generalization of subset-sum problem is called multiple subset-sum problem, in which multiple bins exist with the same capacity. It has been shown that the generalization does not have an FPTAS.<ref>Alberto Caprara, Hans Kellerer, and Ulrich Pferschy. 2000. The Multiple Subset Sum Problem. SIAM J. on Optimization 11, 2 (February 2000), 308-319.</ref>
| |
| | |
| ==Software==
| |
| | |
| {| class="wikitable"
| |
| |-
| |
| !Name
| |
| !License
| |
| !Brief info
| |
| |-
| |
| |[[OpenOpt]]|| BSD ||Free Python language framework that can use either free or commercial [[Mixed integer linear programming#Integer unknowns|MILP]] and other solvers to solve knapsack problems, possibly constrained, nonlinear, multiobjective, see its [http://openopt.org/KSP KSP] page and [http://openopt.org/Problems other available problems]
| |
| |}
| |
| | |
| ==In Popular Culture==
| |
| * The popular video game series [[The Elder Scrolls]] enforces an example of the knapsack problem. The player is often forced to determine the value of items in their inventory and decide what to keep based on a maximum carry-weight.
| |
| * The webcomic [[xkcd]] features a restaurant-oriented version of the knapsack problem in #comic 287.<ref>http://xkcd.com/287/</ref>
| |
| | |
| ==See also==
| |
| * [[Change-making problem]]
| |
| * [[Combinatorial auction]]
| |
| * [[Combinatorial optimization]]
| |
| * [[Continuous knapsack problem]]
| |
| * [[Cutting stock problem]]
| |
| * [[List of knapsack problems]]
| |
| * [[Packing problem]]
| |
| | |
| ==Notes==
| |
| {{Reflist}}
| |
| | |
| ==References==
| |
| * {{Cite book
| |
| | authorlink = Michael R. Garey
| |
| | first = Michael R. | last = Garey
| |
| | coauthors = [[David S. Johnson]]
| |
| | year = 1979
| |
| | title = [[Computers and Intractability: A Guide to the Theory of NP-Completeness]]
| |
| | publisher = W.H. Freeman
| |
| | isbn = 0-7167-1045-5
| |
| }} A6: MP9, pg.247.
| |
| * <cite name="Kellerer"/>{{cite book | title = Knapsack Problems | author = Kellerer, Hans; Pferschy, Ulrich; Pisinger, David | publisher = Springer | year = 2004 | isbn = 3-540-40286-1|mr=2161720 | doi = 10.1007/978-3-540-24777-7}}</cite>
| |
| * <cite name="Martello"/>{{cite book | title = Knapsack problems: Algorithms and computer interpretations | last1=Martello|first1=Silvano|last2=Toth|first2=Paolo| publisher =Wiley-Interscience | year = 1990 | isbn = 0-471-92420-2|mr=1086874 }}</cite>
| |
| | |
| ==External links==
| |
| *[http://academicearth.org/lectures/knapsack-problem-1 MIT Lecture on the Knapsack Problem and Dynamic Programming]
| |
| *[http://www.cse.unl.edu/~goddard/Courses/CSCE310J/Lectures/Lecture8-DynamicProgramming.pdf Lecture slides on the knapsack problem]
| |
| *[http://download.gna.org/pyasukp PYAsUKP: Yet Another solver for the Unbounded Knapsack Problem], with code taking advantage of the dominance relations in an hybrid algorithm, benchmarks and downloadable copies of some papers.
| |
| *[http://www.diku.dk/~pisinger/ Home page of David Pisinger] with downloadable copies of some papers on the publication list (including "Where are the hard knapsack problems?")
| |
| *[http://rosettacode.org/wiki/Knapsack_Problem Knapsack Problem solutions in many languages] at [[Rosetta Code]]
| |
| *[http://www.personal.kent.edu/~rmuhamma/Algorithms/MyAlgorithms/Dynamic/knapsackdyn.htm Dynamic Programming algorithm to 0/1 Knapsack problem]
| |
| *[http://sites.google.com/site/mikescoderama/Home/0-1-knapsack-problem-in-p 0-1 Knapsack Problem in Python]
| |
| *[http://allievi.sssup.it/jacopo/BB/ Interactive JavaScript branch-and-bound solver]
| |
| *[http://www.nils-haldenwang.de/computer-science/computational-intelligence/genetic-algorithm-vs-0-1-knapsack Solving 0-1-KNAPSACK with Genetic Algorithms in Ruby]
| |
| *[http://www.adaptivebox.net/CILib/code/qkpcodes_link.html Codes for Quadratic Knapsack Problem]
| |
| {{Use dmy dates|date=September 2010}}
| |
| | |
| {{DEFAULTSORT:Knapsack Problem}}
| |
| [[Category:Cryptography]]
| |
| [[Category:Packing problem]]
| |
| [[Category:NP-complete problems]]
| |
| [[Category:Operations research]]
| |
| [[Category:Dynamic programming]]
| |
| [[Category:Combinatorial optimization]]
| |
| [[Category:Weakly NP-complete problems]]
| |
| [[Category:Pseudo-polynomial time algorithms]]
| |
| | |
| {{Link FA|fr}}
| |