# 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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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], 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:

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `#define V_SUM_MAX 1000 ` `#define N_MAX 100 ` `#define W_MAX 10000000 ` ` `  `// To store the states of DP ` `int` `dp[V_SUM_MAX + 1][N_MAX]; ` `bool` `v[V_SUM_MAX + 1][N_MAX]; ` ` `  `// Function to solve the recurrence relation ` `int` `solveDp(``int` `r, ``int` `i, ``int``* w, ``int``* val, ``int` `n) ` `{ ` `    ``// Base cases ` `    ``if` `(r <= 0) ` `        ``return` `0; ` `    ``if` `(i == n) ` `        ``return` `W_MAX; ` `    ``if` `(v[r][i]) ` `        ``return` `dp[r][i]; ` ` `  `    ``// Marking state as solved ` `    ``v[r][i] = 1; ` ` `  `    ``// Recurrence relation ` `    ``dp[r][i] ` `        ``= min(solveDp(r, i + 1, w, val, n), ` `              ``w[i] + solveDp(r - val[i], ` `                             ``i + 1, w, val, n)); ` `    ``return` `dp[r][i]; ` `} ` ` `  `// Function to return the maximum weight ` `int` `maxWeight(``int``* w, ``int``* val, ``int` `n, ``int` `c) ` `{ ` ` `  `    ``// Iterating through all possible values ` `    ``// to find the the largest value that can ` `    ``// be represented by the given weights ` `    ``for` `(``int` `i = V_SUM_MAX; i >= 0; i--) { ` `        ``if` `(solveDp(i, 0, w, val, n) <= c) { ` `            ``return` `i; ` `        ``} ` `    ``} ` `    ``return` `0; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `w[] = { 3, 4, 5 }; ` `    ``int` `val[] = { 30, 50, 60 }; ` `    ``int` `n = ``sizeof``(w) / ``sizeof``(``int``); ` `    ``int` `C = 8; ` ` `  `    ``cout << maxWeight(w, val, n, C); ` ` `  `    ``return` `0; ` `} `

 `// Java implementation of the approach ` `class` `GFG  ` `{ ` `    ``static` `final` `int` `V_SUM_MAX = ``1000``; ` `    ``static` `final` `int` `N_MAX = ``100``; ` `    ``static` `final` `int` `W_MAX = ``10000000``; ` `     `  `    ``// To store the states of DP  ` `    ``static` `int` `dp[][] = ``new` `int``[V_SUM_MAX + ``1``][N_MAX];  ` `    ``static` `boolean` `v[][] = ``new` `boolean` `[V_SUM_MAX + ``1``][N_MAX];  ` `     `  `    ``// Function to solve the recurrence relation  ` `    ``static` `int` `solveDp(``int` `r, ``int` `i, ``int` `w[],        ` `                          ``int` `val[], ``int` `n)  ` `    ``{  ` `        ``// Base cases  ` `        ``if` `(r <= ``0``)  ` `            ``return` `0``;  ` `             `  `        ``if` `(i == n)  ` `            ``return` `W_MAX;  ` `             `  `        ``if` `(v[r][i])  ` `            ``return` `dp[r][i];  ` `     `  `        ``// Marking state as solved  ` `        ``v[r][i] = ``true``;  ` `     `  `        ``// Recurrence relation  ` `        ``dp[r][i] = Math.min(solveDp(r, i + ``1``, w, val, n),  ` `                     ``w[i] + solveDp(r - val[i],  ` `                                    ``i + ``1``, w, val, n));  ` `         `  `        ``return` `dp[r][i];  ` `    ``}  ` `     `  `    ``// Function to return the maximum weight  ` `    ``static` `int` `maxWeight(``int` `w[], ``int` `val[],  ` `                         ``int` `n, ``int` `c)  ` `    ``{  ` `     `  `        ``// Iterating through all possible values  ` `        ``// to find the the largest value that can  ` `        ``// be represented by the given weights  ` `        ``for` `(``int` `i = V_SUM_MAX; i >= ``0``; i--) ` `        ``{  ` `            ``if` `(solveDp(i, ``0``, w, val, n) <= c)  ` `            ``{  ` `                ``return` `i;  ` `            ``}  ` `        ``}  ` `        ``return` `0``;  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `main (String[] args) ` `    ``{  ` `        ``int` `w[] = { ``3``, ``4``, ``5` `};  ` `        ``int` `val[] = { ``30``, ``50``, ``60` `};  ` `        ``int` `n = w.length;  ` `        ``int` `C = ``8``;  ` `     `  `        ``System.out.println(maxWeight(w, val, n, C));  ` `    ``}  ` `} ` ` `  `// This code is contributed by AnkitRai01 `

 `# Python3 implementation of the approach ` `V_SUM_MAX ``=` `1000` `N_MAX ``=` `100` `W_MAX ``=` `10000000` ` `  `# To store the states of DP ` `dp ``=` `[[ ``0` `for` `i ``in` `range``(N_MAX)] ` `          ``for` `i ``in` `range``(V_SUM_MAX ``+` `1``)] ` `v ``=` `[[ ``0` `for` `i ``in` `range``(N_MAX)] ` `         ``for` `i ``in` `range``(V_SUM_MAX ``+` `1``)] ` ` `  `# Function to solve the recurrence relation ` `def` `solveDp(r, i, w, val, n): ` `     `  `    ``# Base cases ` `    ``if` `(r <``=` `0``): ` `        ``return` `0` `    ``if` `(i ``=``=` `n): ` `        ``return` `W_MAX ` `    ``if` `(v[r][i]): ` `        ``return` `dp[r][i] ` ` `  `    ``# Marking state as solved ` `    ``v[r][i] ``=` `1` ` `  `    ``# Recurrence relation ` `    ``dp[r][i] ``=` `min``(solveDp(r, i ``+` `1``, w, val, n),  ` `            ``w[i] ``+` `solveDp(r ``-` `val[i], i ``+` `1``, ` `                            ``w, val, n)) ` `    ``return` `dp[r][i] ` ` `  `# Function to return the maximum weight ` `def` `maxWeight( w, val, n, c): ` ` `  `    ``# Iterating through all possible values ` `    ``# to find the the largest value that can ` `    ``# be represented by the given weights ` `    ``for` `i ``in` `range``(V_SUM_MAX, ``-``1``, ``-``1``): ` `        ``if` `(solveDp(i, ``0``, w, val, n) <``=` `c): ` `            ``return` `i ` ` `  `    ``return` `0` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``w ``=` `[``3``, ``4``, ``5``] ` `    ``val ``=` `[``30``, ``50``, ``60``] ` `    ``n ``=` `len``(w) ` `    ``C ``=` `8` ` `  `    ``print``(maxWeight(w, val, n, C)) ` ` `  `# This code is contributed by Mohit Kumar `

 `// C# implementation of the approach ` `using` `System; ` ` `  `class` `GFG  ` `{ ` `    ``static` `readonly` `int` `V_SUM_MAX = 1000; ` `    ``static` `readonly` `int` `N_MAX = 100; ` `    ``static` `readonly` `int` `W_MAX = 10000000; ` `     `  `    ``// To store the states of DP  ` `    ``static` `int` `[,]dp = ``new` `int``[V_SUM_MAX + 1, N_MAX];  ` `    ``static` `bool` `[,]v = ``new` `bool` `[V_SUM_MAX + 1, N_MAX];  ` `     `  `    ``// Function to solve the recurrence relation  ` `    ``static` `int` `solveDp(``int` `r, ``int` `i, ``int` `[]w,      ` `                       ``int` `[]val, ``int` `n)  ` `    ``{  ` `        ``// Base cases  ` `        ``if` `(r <= 0)  ` `            ``return` `0;  ` `             `  `        ``if` `(i == n)  ` `            ``return` `W_MAX;  ` `             `  `        ``if` `(v[r, i])  ` `            ``return` `dp[r, i];  ` `     `  `        ``// Marking state as solved  ` `        ``v[r, i] = ``true``;  ` `     `  `        ``// Recurrence relation  ` `        ``dp[r, i] = Math.Min(solveDp(r, i + 1, w, val, n),  ` `                     ``w[i] + solveDp(r - val[i],  ` `                                    ``i + 1, w, val, n));  ` `         `  `        ``return` `dp[r, i];  ` `    ``}  ` `     `  `    ``// Function to return the maximum weight  ` `    ``static` `int` `maxWeight(``int` `[]w, ``int` `[]val,  ` `                         ``int` `n, ``int` `c)  ` `    ``{  ` `     `  `        ``// Iterating through all possible values  ` `        ``// to find the the largest value that can  ` `        ``// be represented by the given weights  ` `        ``for` `(``int` `i = V_SUM_MAX; i >= 0; i--) ` `        ``{  ` `            ``if` `(solveDp(i, 0, w, val, n) <= c)  ` `            ``{  ` `                ``return` `i;  ` `            ``}  ` `        ``}  ` `        ``return` `0;  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `Main(String[] args) ` `    ``{  ` `        ``int` `[]w = { 3, 4, 5 };  ` `        ``int` `[]val = { 30, 50, 60 };  ` `        ``int` `n = w.Length;  ` `        ``int` `C = 8;  ` `     `  `        ``Console.WriteLine(maxWeight(w, val, n, C));  ` `    ``}  ` `} ` ` `  `// This code is contributed by 29AjayKumar `

Output:
```90
```

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

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :