Can not understand knapsack solutions

Question

In wikipedia the algorithm for Knapsack is as follows:

for i from 1 to n do  
  for j from 0 to W do  
    if j >= w[i] then  
      T[i, j] := max(T[i-1, j], T[i-1, j-w[i]] + v[i]) [18]  
    else  
      T[i, j] := T[i-1, j]  
    end if  
  end for  
end for  

And it is the same structures on all examples I found online.
What I can not understand is how does this code take into account the fact that perhaps the max value comes from a smaller knapsack? E.g. if the knapsack capacity is 8 then perhaps max value comes from capacity 7 (8 - 1).
I could not find anywhere logic to consider that perhaps the max value comes from a smaller knapsack. Is this wrong idea?

Answer 1

The Dynamic Programming solution of knapsack is basically recursive:

T(i,j) = max{ T(i-1,j) ,         T(i-1,j-w[i]) + v[i] }
       //      ^                         ^
       //  ignore the element       add the element, your value is increase
       //                           by v[i] and the additional weight you can
       //                           carry is decreased by w[i]

(The else condition is redundant in the recursive form if you set T(i,j) = -infinity for each j < 0).

The idea is exhaustive search, you start from one element and you have two possibilities: add it, or don't.
You check both options, and chose the best of those.

Since it is done recursively - you effectively checking ALL possibilities to assign the elements to the knapsack.

Note that the solution in wikipedia is basically a bottom-up solution for the same recursive formula

Answer 2

As I see, you have misunderstood the concept of knapsack. which I will describe here in details till we reach the code part.

First, there are two versions of the problem:

1. 0-1 knapsack problem: here, the Items are indivisible, you either take an item or not. and can be solved with dynamic programming. //and this one is the one yo are facing problems with
2. Fractional knapsack problem: don't care about this one now.

For the first problem you can understand it as the following:

Given a knapsack with maximum capacity W, and a set S consisting of n items Each item i has some weight wi and benefit value bi (all wi and W are integer values).

SO, How to pack the knapsack to achieve maximum total value of packed items?

and in mathematical mouth:

and to solve this problem using Dynamic Programming We set up a table V[0..k, 0..W] with one row for each available item, and one column for each weight from 0 to W. We need to carefully identify the sub-problems,

The sub-problem then will be to compute V[k,w], i.e., to find an optimal solution for Sk= {items labeled 1, 2, .. k} in a knapsack of size w (maximum value achievable given capacity w and items 1,…, k)

So, we found this formula to solve our problem:

This algorithm only finds the max possible value that can be carried in the knapsack i.e., the value in V[n,W] To know the items that make this maximum value, this will be another topic.

I really hope that this answer will help you. I have an pp presentation that walks with you to fill the table and to show you the algorithm step by step. But I don't know how can I upload it to stackoverflow. let me know if any help needed.