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

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


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




My Personal Notes arrow_drop_up

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.