Date: 11/02/98

The 0-1 Knapsack problem was discussed in detail in class and the discussion centered on finding an algorithm that gives the optimal solution not necessarily in polynomial time.

INTRODUCTION:

The knapsack problem arises whenever there is resource allocation with cost constraints. Given a fixed budget, how do you select what things to buy? Everything has a cost and value, so we seek the most value for a given cost. The term Knapsack problem invokes the image of the backpacker who is constrained by a fixed-size knapsack and so must fill it only with the most useful items.

Knapsack problem is a classical problem in Integer Programming in the field of Operations Research. In industry and financial management, many real-world problems relate to the Knapsack problem. For example, cutting stock, cargo loading, production scheduling, project selection, capital budgeting, and portfolio management. Since it is NP-hard, the knapsack problem is the basis for a public key encryption system.

The constraint in the 0/1 Knapsack problem is that each item must be put entirely in the knapsack or not included at all. Objects cannot be broken up (i.e. included fractionally), so it is not fair taking one can of coke from a six-pack or opening the can to take just a sip. It is this 0/1 property that makes the knapsack problem hard, for a simple greedy algorithm finds the optimal selection whenever we are allowed to subdivide objects arbitrarily. For each item, we could compute its "price per pound", i.e. value per unit cost and take as much of the most expensive item until we have it all or the knapsack is full. Repeat with the next most expensive item, until the knapsack is full. Unfortunately, this 0/1 constraint is usually inherent in most applications.

EXAMPLE:

Given objects of weight values W_n and values V_n associated with them

Knapsack weight bound is "B"
 

Objective:
 

Maximize the value for the Knapsack.

CASE I : Weights are Integers

Assumptions:

• Weights are integers. [We can equally well have assumed the values to be integers and this case is taken up later.]
• Maximum weight is W_max.
• The Knapsack weight bound ‘B’ is also assumed to be an integer.

Algorithm:

We can build a matrix as shown below with the weight bounds as the columns and the number of items as the rows.
 
 

	1	2	3	….	……	j	…..	…..	B
1
2
…
i
…
n

 

If we assume that,

M [i, j] = maximum value of a Knapsack with weight bound equal to j and using items from the list { 1, 2, 3, ……., i} then,

M[n, B] is the solution as it gives the maximum value of item n with weight bound B taken from the items {1,2,3,….n}.

The matrix is filled up using the following formula:

M [i, j] = Maximum {

If we modify the problem to allow only one copy of each item :

M[i,j] = maximum {

V₁ if j ³ W₁ }
 

Time Complexity:

Each entry is computed in constant time. Therefore the time complexity = O(nB).

The problem with this algorithm is that from the time complexity it is clear that if n or B are multiplied by a factor of 10, time complexity also increases by 10 times. This implies that time complexity is not polynomial in the length of the input.

Therefore, this is not a polynomial time algorithm. In fact, it is a Pseudo-polynomial time algorithm.

In order to understand this properly, we first compute the length of the input.

The length of encoding for writing down number ‘n’ is (log n) = |n|

Similarly for,

W₁ the length of encoding is (log W₁) = | W₁|

W₂ the length of encoding is (log W₂) = | W₂|

…. ….

…. ….

W_n the length of encoding is (log W_n ) = | W_n| and

V₁ the length of encoding is (log V₁) = | V₁|

V₂ the length of encoding is (log V₂) = | V₂|

…. ….

…. ….

V_n the length of encoding is (log V_n) = | V_n |

B the length of encoding is (log B) = |B|

B is atmost the sum of all the above numbers and values are ignored as they don’t really matter for running time.

If W_max is the maximum weight in the set, then

| W₁ | £ | W_max |

| W₂ | £ | W_max |

…. ….

…. ….

| W_n | £ | W_max|

and

B£ n| W_max |

Length of the input = O (n log W_max ) ------------ (1)

Time complexity = O (nB)

= O (n² W_max )----(2)

From (1) and (2) it is clear that the time complexity is not polynomial in the length of the input. ( log X and X hold an exponential relationship and not a polynomial one)

Algorithms of this type are called Pseudo polynomial algorithms.
 

Case II : Values are integers

Now, in the case where we assume the values to be integers we build a new matrix F, such that

F[i,j] = Minimum weight bound needed for a Knapsack to contain value of atleast j using items from { 1, 2, 3, ………., i}

Now, the corresponding recurrence is :

F[i, j] = min { F[i-1,j], F[i-1,j-V_i]+ W_i }

F[1,j] = { Wi if j £ V₁

• if j > V₁ }

EXAMPLE:

Consider a set of 3 items with :

Weights: 20, 30, 10

Values: 100,120,60.

 
 

0	2	4	6	8	10	12	14	16	18	20	22	24
0	2	2	2	2	2	µ	µ	µ	µ	µ	µ	µ
0	2	2	2	2	2	3	5	5	5	5	5	µ
0	1	1	1	2	2	3	3	3	4	5	5	6

 

Observations:

• Fill things up column by column.
• Anytime the last column has all values greater than B then delete that column and stop.

• The value corresponding to the rightmost column (in which B appears) is the maximum value that can be picked up with a Knapsack of weight bound B.
• Note that no matter in what order the values ( W_i ,V_i) are given, the last row will turn out to be the same.
• Time complexity ( = number of rows X columns) = O(nV*), where V* is the value of the optimal Knapsack.
• New Idea for speeding : Scale all values by k, i.e. V_i = [V_i /k], I = 1, 2, 3, ….., n

• Absolute error in value = kn; k is the factor by which we divide, n is the number of items.
• Relative error = kn/V* £ kn/V_max
• Picking "k" carefully can bound the error to whatever we want.
• For making the algorithm Polynomial in time: Pick k = 1/(4e ² V₀) and process the items in decreasing order of vi/wi. Then relative error = e and time complexity = O(nlog₂(1/e ) + 1/e ⁴).

For an optimal answer, e has to be exponentially small, in which case running time is no more polynomial.

 
Algorithm for 0-1 Knapsack problem(Case I):
 

The following algorithm for solving the 0-1Knapsack problem takes as input

-- B, the capacity of the knapsack

-- n, the number of items

-- a vector w[1::n] where w[i] is the weight of the i-th item

-- vector v[1::n] where v[i] is the value of the i-th item.

The capacity, weights, and values are assumed to be positive integers. The algorithm makes use of an auxiliary array A[0:::n; 0:::B].
 

0-1Knapsack(n; B; w; v)

1. for i = 0 to n

2. do A[i; 0] 0

3. for j = 0 to B

4. do A[0; j] 0

5. for j = 1 to B

6. do for i = 1 to n

7. if w[i] > j

8. then A[i; j] A[i _1; j]

9. else if A[i _1; j] > A[i _1; j _ w[i]] + v[i]

10. then A[i; j] A[i _1; j]

11. else A[i; j] A[i _1; j _ w[i]] + v[i]

12. return A[n; B]
 

Some sites of interest describing Knapsack Problem:

http://www-sop.inria.fr/rodeo/personnel/hoschka/lastpaper/node5.html

http://alia.dj.kit.ac.jp/public/DDD_e.html

http://www-personal.monash.edu.au/~mecheng/mec3409/softeng/complexi/node5.html

http://www.math.grin.edu/~stone/courses/software-design/greedy-algorithms.html

http://www.maths.mu.oz.au/~moshe/recor/knapsack/knapsack.html

http://www.csc.lin.ac.uk/~ped/teachadmin/algor/algor_complete.html