Dynamic 1/1 Knapsack

• Assume n items of weights w₁ ... w_n. and values v₁ to v_n
• further assume w_i is an integer and w_i > 0 for i≤ n
• Let F(i,j) be the optimal solution (value) for the first i items, totaling to weight j.
  • Like the change making problem, we will build a table that goes from weight 0 to weight W, where W is the maximum weight of our knapsack.
  • And we will go from 0 items to n items.

  • 
             | 0          for i=1 or j = 0   (no space, no items)
    F(i,j) = | F(i-1,j)   if j-wi < 0 (the item is too big)
             | max[F(i-1,j), vi+F(i-1,j-wi)] if j-wi ≥ 0
    	  

  • In the last case
    • it is either the value of the previous set, (ie without this item, it does not increase the value enough to drop something else)
    • Or it is the previous set with a weight less than this item plus this item (drop something else).
• Example v = {10,40,30,50) w = {5,4,6,3} and W = 10

    F(i,w)  0   1   2   3   4   5   6   7   8   9   10
       0    0   0   0   0   0   0   0   0   0   0    0
       1    0   0   0   0   0  10  10  10  10  10   10
       2    0
       3    0     This is clear, as the rows for 0 are 0 
       4    0         and the row for 1 is only 10 when the weight is 5 or more
  
       
  
    F(i,w)  0   1   2   3   4   5   6   7   8   9   10
       0    0   0   0   0   0   0   0   0   0   0    0
       1    0   0   0   0   0  10  10  10  10  10   10
       2    0   0   0   0  40  40  40  40  40  50   50 <- take both
       3    0              ------------------  since 40+0 ≥ 10+0 
       4    0                
  
       
    F(i,w)  0   1   2   3   4   5   6   7   8   9   10
       0    0   0   0   0   0   0   0   0   0   0    0
       1    0   0   0   0   0  10  10  10  10  10   10
       2    0   0   0   0  40  40  40  40  40  50   50  50 = 40+F(1,9-4)
       3    0   0   0   0  40  40  40  40  40  50   70  70 = 30+F(2,10-6)
       4    0   0   0  50  50  50  50  90  90  90   90    
       

• This is Θ(W,n), and has a restriction on the weights of the items.
• Reconstruct the solution by working backwards
  • Maximum solution is in F(4,10), look at F(3,10) they are different so item 4 was added.
  • Now the maximum solution must be at F(3, 10-w₄), F(3, 7)
  • Look at F(3,7) = 40, but F(2,7)=40, so it must not be item 3
  • Look at F(2,7) = 40, F(1,7) = 10, so it must be item 2, and now we move back to F(1,7-w₂) = F(1,3) = 0, so item 1 was not taken.
• Why is this not a polynomial time to 0/1 knapsack?
  • Assume the weight 5, and that we have 4 items
  • And the weights of our items is integer
    • We just saw that this is O(4*5) = 20
  • Now assume the weights are in the form a.b (ie 3.2)
    • The table will need to be 0, 0.1, 0.2 ...
    • IE O(5*10*4)
  • Now assume the weights are in the form a.bc (ie 3.21)
    • The table will need to be 0, 0.01, 0.02 ...
    • O(5*10*10*4)
  • Or in general
    • O(w*10^d*n)
    • Where d is the number of digits to the right of the decimal point
• Notice that if we really only need the previous row for the stepwise solution.
• And if we kept the list of items that contributed to each solution at each step, we could throw away most of the table.