Knapsack with large Weights

Given a knapsack with capacity C and two arrays w[] and val[] representing the weights and values of N distinct items, the task is to find the maximum value you can put into the knapsack. Items cannot be broken and an item with weight X takes X capacity of the knapsack.

Examples: 

Input: w[] = {3, 4, 5}, val[] = {30, 50, 60}, C = 8 
Output: 90 
We take objects '1' and '3'. 
The total value we get is (30 + 60) = 90. 
Total weight is 8, thus it fits in the given capacity

Input: w[] = {10000}, val[] = {10}, C = 100000 
Output: 10  

Approach: The traditional famous 0-1 knapsack problem can be solved in O(N*C) time but if the capacity of the knapsack is huge then a 2D N*C array can't make be made. Luckily, it can be solved by redefining the states of the dp. 
Let's have a look at the states of the DP first.
dp[V][i] represents the minimum weight subset of the subarray arr[i...N-1] required to get a value of at least V. The recurrence relation will be:

dp[V][i] = min(dp[V][i+1], w[i] + dp[V - val[i]][i + 1]) 

So, for each V from 0 to the maximum value of V possible, try to find if the given V can be represented with the given array. The largest such V that can be represented becomes the required answer.

Below is the implementation of the above approach: 

90

Time Complexity: O(V_sum * N) where V_sum is the sum of all the values in the array val[].
Auxiliary Space : O(V_sum * N) where V_sum is the sum of all the values in the array val[].

Efficient approach : Using DP Tabulation method ( Iterative approach )

The approach to solve this problem is same but DP tabulation(bottom-up) method is better then Dp + memoization(top-down) because memoization method needs extra stack space of recursion calls.

Steps to solve this problem :

• Create a table DP to store the solution of the subproblems.
• Initialize the table with base cases
• Now Iterate over subproblems to get the value of current problem form previous computation of subproblems stored in DP
• At last get the maximum value from DP and return the final solution.

Implementation :

Output

90 

Time Complexity: O(V_sum * N).
Auxiliary Space : O(V_sum * N).