Double Knapsack | Dynamic Programming
Last Updated : 16 Nov, 2024
Given an array arr[] containing the weight of 'n' distinct items, and two knapsacks that can withstand capactiy1 and capacity2 weights, the task is to find the sum of the largest subset of the array 'arr', that can be fit in the two knapsacks. It's not allowed to break any items in two, i.e. an item should be put in one of the bags as a whole.
Examples:
Input: arr[] = [8, 3, 2], capacity1 = 10, capacity2 = 3
Output: 13
Explanation: The first and third items are placed in the first knapsack, while the second item is placed in the second knapsack. This results in a total weight of 13.
Input: arr[] = [8, 5, 3] capacity1 = 10, capacity2 = 3
Output: 11
Explanation: The first item is placed in the first knapsack, and the third item is placed in the second knapsack. This results in a total weight of 11.
Using Recursion– O(2^n) Time and O(n) Space
A recursive solutions is to try out all the possible ways of filling the two knapsacks and choose the one giving the maximum weight.
Every item has 3 choices:
Don't include the current item: If we don't include the current item (i.e., arr[curr]), the maximum weight is simply the same as if we move on to the next item, keeping both knapsack capacities unchanged:
- findMaxWeight(curr, n, arr, capacity1, capacity2) = findMaxWeight(curr+1, n, arr, capacity1, capacity2)
Include the current item in the first knapsack: If the current item can fit into the first knapsack (i.e., arr[curr] ≤ capacity1), then we include it in the first knapsack, reduce the capacity of the first knapsack by arr[curr], and proceed to the next item with updated capacities. The recurrence relation for this choice is:
- findMaxWeight(curr, n, arr, capacity1, capacity2) = max(findMaxWeight(curr+1, n, arr, capacity1-arr[cur], capacity2)+arr[curr], findMaxWeight(curr+1, n, arr, capacity1, capacity2))
Include the current item in the second knapsack: If the current item can fit into the second knapsack (i.e., arr[curr] ≤ capacity2), then we include it in the second knapsack, reduce the capacity of the second knapsack by arr[curr], and proceed to the next item with updated capacities. The recurrence relation for this choice is:
- findMaxWeight(curr, n, arr, capacity1, capacity2) = max(findMaxWeight(curr+1, n, arr, capacity1, capacity2-arr[curr])+arr[curr], findMaxWeight(curr+1, n, arr, capacity1, capacity2))
C++ // C++ program to find the largest subset of // the array that can fit into two knapsack // using recursion #include <iostream> #include <vector> using namespace std; int findMaxWeight(int curr, int n, vector<int> &arr, int capacity1, int capacity2) { // Base case: if all items have been considered if (curr >= n) return 0; // Option 1: Don't take the current item int res = findMaxWeight(curr + 1, n, arr, capacity1, capacity2); // Option 2: If the current item can be // added to the first knapsack, do it if (capacity1 >= arr[curr]) { int takeInFirst = arr[curr] + findMaxWeight(curr + 1, n, arr, capacity1 - arr[curr], capacity2); res = max(res, takeInFirst); } // Option 3: If the current item can be // added to the second knapsack, do it if (capacity2 >= arr[curr]) { int takeInSecond = arr[curr] + findMaxWeight(curr + 1, n, arr, capacity1, capacity2 - arr[curr]); res = max(res, takeInSecond); } return res; } int maxWeight(vector<int> &arr, int capacity1, int capacity2) { int n = arr.size(); int res = findMaxWeight(0, n, arr, capacity1, capacity2); return res; } int main() { vector<int> arr = {8, 2, 3}; int capacity1 = 10, capacity2 = 3; int res = maxWeight(arr, capacity1, capacity2); cout << res; return 0; } // Java program to find the largest subset of // the array that can fit into two knapsacks // using recursion import java.util.*; class GfG { static int findMaxWeight(int curr, int n, int[] arr, int capacity1, int capacity2) { // Base case: if all items have been considered if (curr >= n) return 0; // Option 1: Don't take the current item int res = findMaxWeight(curr + 1, n, arr, capacity1, capacity2); // Option 2: If the current item can be // added to the first knapsack, do it if (capacity1 >= arr[curr]) { int takeInFirst = arr[curr] + findMaxWeight(curr + 1, n, arr, capacity1 - arr[curr], capacity2); res = Math.max(res, takeInFirst); } // Option 3: If the current item can be // added to the second knapsack, do it if (capacity2 >= arr[curr]) { int takeInSecond = arr[curr] + findMaxWeight(curr + 1, n, arr, capacity1, capacity2 - arr[curr]); res = Math.max(res, takeInSecond); } return res; } static int maxWeight(int[] arr, int capacity1, int capacity2) { int n = arr.length; int res = findMaxWeight(0, n, arr, capacity1, capacity2); return res; } public static void main(String[] args) { int[] arr = { 8, 2, 3 }; int capacity1 = 10, capacity2 = 3; int res = maxWeight(arr, capacity1, capacity2); System.out.println(res); } } # Python program to find the largest subset of # the array that can fit into two knapsacks # using recursion def findMaxWeight(curr, n, arr, capacity1, capacity2): # Base case: if all items have been considered if curr >= n: return 0 # Option 1: Don't take the current item res = findMaxWeight(curr + 1, n, arr, capacity1, capacity2) # Option 2: If the current item can be # added to the first knapsack, do it if capacity1 >= arr[curr]: takeInFirst = arr[curr] + \ findMaxWeight(curr + 1, n, arr, capacity1 - arr[curr], capacity2) res = max(res, takeInFirst) # Option 3: If the current item can be # added to the second knapsack, do it if capacity2 >= arr[curr]: takeInSecond = arr[curr] + \ findMaxWeight(curr + 1, n, arr, capacity1, capacity2 - arr[curr]) res = max(res, takeInSecond) return res def maxWeight(arr, capacity1, capacity2): n = len(arr) res = findMaxWeight(0, n, arr, capacity1, capacity2) return res if __name__ == "__main__": arr = [8, 2, 3] capacity1 = 10 capacity2 = 3 res = maxWeight(arr, capacity1, capacity2) print(res)
// C# program to find the largest subset of // the array that can fit into two knapsacks // using recursion using System; class GfG { static int findMaxWeight(int curr, int n, int[] arr, int capacity1, int capacity2) { // Base case: if all items have been considered if (curr >= n) return 0; // Option 1: Don't take the current item int res = findMaxWeight(curr + 1, n, arr, capacity1, capacity2); // Option 2: If the current item can be // added to the first knapsack, do it if (capacity1 >= arr[curr]) { int takeInFirst = arr[curr] + findMaxWeight(curr + 1, n, arr, capacity1 - arr[curr], capacity2); res = Math.Max(res, takeInFirst); } // Option 3: If the current item can be // added to the second knapsack, do it if (capacity2 >= arr[curr]) { int takeInSecond = arr[curr] + findMaxWeight(curr + 1, n, arr, capacity1, capacity2 - arr[curr]); res = Math.Max(res, takeInSecond); } return res; } static int maxWeight(int[] arr, int capacity1, int capacity2) { int n = arr.Length; int res = findMaxWeight(0, n, arr, capacity1, capacity2); return res; } static void Main(string[] args) { int[] arr = { 8, 2, 3 }; int capacity1 = 10, capacity2 = 3; int res=maxWeight(arr, capacity1, capacity2); Console.WriteLine(res); } } // JavaScript program to find the largest subset of // the array that can fit into two knapsacks // using recursion function findMaxWeight(curr, n, arr, capacity1, capacity2) { // Base case: if all items have been considered if (curr >= n) return 0; // Option 1: Don't take the current item let res = findMaxWeight(curr + 1, n, arr, capacity1, capacity2); // Option 2: If the current item can be // added to the first knapsack, do it if (capacity1 >= arr[curr]) { let takeInFirst = arr[curr] + findMaxWeight(curr + 1, n, arr, capacity1 - arr[curr], capacity2); res = Math.max(res, takeInFirst); } // Option 3: If the current item can be // added to the second knapsack, do it if (capacity2 >= arr[curr]) { let takeInSecond = arr[curr] + findMaxWeight(curr + 1, n, arr, capacity1, capacity2 - arr[curr]); res = Math.max(res, takeInSecond); } return res; } function maxWeight(arr, capacity1, capacity2) { let n = arr.length; let res = findMaxWeight(0, n, arr, capacity1, capacity2); return res; } let arr = [ 8, 2, 3 ]; let capacity1 = 10, capacity2 = 3; let res = maxWeight(arr, capacity1,capacity2); console.log(res); Using Memoization – O(n*capacity1*capacity2) Time and O(n*capacity1*capacity2) Space
If we notice carefully, we can observe that the above recursive solution holds the following two properties of Dynamic Programming.
1. Optimal Substructure: The solution to the two-knapsack problem can be derived from the optimal solutions of smaller subproblems. Specifically, for any given n (the number of items considered) and the remaining capacities of the two knapsacks (capacity1 and capacity2), we can express the recursive relation as follows.
2. Overlapping Subproblems: In the recursive solution to the problem of maximizing the weight in two knapsacks, we observe that many subproblems are computed multiple times, which leads to overlapping subproblems.
- We need to track all three parameters, so we create a 3D memoization table of size (n+1) x (capacity1+1) x (capacity2+1).
- This table is initialized with -1 to indicate that no subproblems have been computed yet.
- If the value at memo[curr][capacity1][capacity2] is not -1, return the already computed result to avoid recomputing the same subproblem.
C++ // C++ program to find the largest subset of // the array that can fit into two knapsack // using memoization #include <iostream> #include <vector> using namespace std; int findMaxWeight(int curr, int n, vector<int> &arr, int capacity1, int capacity2, vector<vector<vector<int>>> &memo) { // Base case: If all items have been considered, // return 0 as no more items can be added if (curr >= n) return 0; // If the result for this subproblem is already // computed, return the memoized value if (memo[curr][capacity1][capacity2] != -1) return memo[curr][capacity1][capacity2]; // Option 1: Don't take the current item, and // proceed to the next item int res = findMaxWeight(curr + 1, n, arr, capacity1, capacity2, memo); // Option 2: If the current item can be added // to the first knapsack, include it if (capacity1 >= arr[curr]) { int takeInFirst = arr[curr] + findMaxWeight(curr + 1, n, arr, capacity1 - arr[curr], capacity2, memo); res = max(res, takeInFirst); } // Option 3: If the current item can be added // to the second knapsack, include it if (capacity2 >= arr[curr]) { int takeInSecond = arr[curr] + findMaxWeight(curr + 1, n, arr, capacity1, capacity2 - arr[curr], memo); res = max(res, takeInSecond); } return memo[curr][capacity1][capacity2] = res; } int maxWeight(vector<int> &arr, int capacity1, int capacity2) { int n = arr.size(); vector<vector<vector<int>>> memo = vector<vector<vector<int>>>(n, vector<vector<int>> (capacity1 + 1, vector<int>(capacity2 + 1, -1))); int res = findMaxWeight(0, n, arr, capacity1, capacity2, memo); return res; } int main() { vector<int> arr = {8, 2, 3}; int capacity1 = 10, capacity2 = 3; int res=maxWeight(arr, capacity1, capacity2); cout << res; return 0; } // Java program to find the largest subset of // the array that can fit into two knapsack // using memoization import java.util.*; class GfG { static int findMaxWeight(int curr, int n, int[] arr, int capacity1, int capacity2, int[][][] memo) { // Base case: if all items have been considered if (curr >= n) { return 0; } // If the result is already computed for this // subproblem, return it if (memo[curr][capacity1][capacity2] != -1) { return memo[curr][capacity1][capacity2]; } // Option 1: Don't take the current item int res = findMaxWeight(curr + 1, n, arr, capacity1, capacity2, memo); // Option 2: If the current item can be added // to the first knapsack, do it if (capacity1 >= arr[curr]) { int takeInFirst = arr[curr] + findMaxWeight(curr + 1, n, arr, capacity1 - arr[curr], capacity2, memo); res = Math.max(res, takeInFirst); } // Option 3: If the current item can be added to the // second knapsack, do it if (capacity2 >= arr[curr]) { int takeInSecond = arr[curr] + findMaxWeight(curr + 1, n, arr, capacity1, capacity2 - arr[curr], memo); res = Math.max(res, takeInSecond); } // Store the result in the memoization table and // return it memo[curr][capacity1][capacity2] = res; return res; } static int maxWeight(int[] arr, int capacity1, int capacity2) { int n = arr.length; // Create a memoization table with all values // initialized to -1 int[][][] memo = new int[n][capacity1 + 1][capacity2 + 1]; // Initialize memoization table with -1 for (int i = 0; i < n; i++) { for (int j = 0; j <= capacity1; j++) { for (int k = 0; k <= capacity2; k++) { memo[i][j][k] = -1; } } } return findMaxWeight(0, n, arr, capacity1, capacity2, memo); } public static void main(String[] args) { int[] arr = { 8, 2, 3 }; int capacity1 = 10, capacity2 = 3; int res = maxWeight(arr, capacity1, capacity2); System.out.println(res); } } # Python program to find the largest subset of # the array that can fit into two knapsack # using memoization def findMaxWeight(curr, n, arr, capacity1, capacity2, memo): # Base case: if all items have been considered if curr >= n: return 0 # If the result is already computed for # this subproblem, return it if memo[curr][capacity1][capacity2] != -1: return memo[curr][capacity1][capacity2] # Option 1: Don't take the current item res = findMaxWeight(curr + 1, n, arr, capacity1, capacity2, memo) # Option 2: If the current item can be added # to the first knapsack, do it if capacity1 >= arr[curr]: takeInFirst = arr[curr] + \ findMaxWeight(curr + 1, n, arr, capacity1 - arr[curr], capacity2, memo) res = max(res, takeInFirst) # Option 3: If the current item can be added # to the second knapsack, do it if capacity2 >= arr[curr]: takeInSecond = arr[curr] + \ findMaxWeight(curr + 1, n, arr, capacity1, capacity2 - arr[curr], memo) res = max(res, takeInSecond) # Store the result in the memoization table and # return it memo[curr][capacity1][capacity2] = res return res def maxWeight(arr, capacity1, capacity2): n = len(arr) # Create a memoization table with all values # initialized to -1 memo = [[[-1 for _ in range(capacity2 + 1)] for _ in range(capacity1 + 1)] for _ in range(n)] return findMaxWeight(0, n, arr, capacity1, capacity2, memo) if __name__ == "__main__": arr = [8, 2, 3] capacity1 = 10 capacity2 = 3 res = maxWeight(arr, capacity1, capacity2) print(res)
// C# program to find the largest subset of // the array that can fit into two knapsack // using memoization using System; class GfG { static int findMaxWeight(int curr, int n, int[] arr, int capacity1, int capacity2, int[, , ] memo) { // Base case: if all items have been considered if (curr >= n) return 0; // If the result is already computed for this // subproblem, return it if (memo[curr, capacity1, capacity2] != -1) return memo[curr, capacity1, capacity2]; // Option 1: Don't take the current item int res = findMaxWeight(curr + 1, n, arr, capacity1, capacity2, memo); // Option 2: If the current item can be added to the // first knapsack, do it if (capacity1 >= arr[curr]) { int takeInFirst = arr[curr] + findMaxWeight(curr + 1, n, arr, capacity1 - arr[curr], capacity2, memo); res = Math.Max(res, takeInFirst); } // Option 3: If the current item can be added to the // second knapsack, do it if (capacity2 >= arr[curr]) { int takeInSecond = arr[curr] + findMaxWeight(curr + 1, n, arr, capacity1, capacity2 - arr[curr], memo); res = Math.Max(res, takeInSecond); } // Store the result in the memoization table and // return it memo[curr, capacity1, capacity2] = res; return res; } static int maxWeight(int[] arr, int capacity1, int capacity2) { int n = arr.Length; // Create a memoization table with all values // initialized to -1 int[, , ] memo = new int[n, capacity1 + 1, capacity2 + 1]; for (int i = 0; i < n; i++) { for (int j = 0; j <= capacity1; j++) { for (int k = 0; k <= capacity2; k++) { memo[i, j, k] = -1; } } } return findMaxWeight(0, n, arr, capacity1, capacity2, memo); } static void Main() { int[] arr = { 8, 2, 3 }; int capacity1 = 10; int capacity2 = 3; int res = maxWeight(arr, capacity1, capacity2); Console.WriteLine(res); } } // JavaScript program to find the largest subset of // the array that can fit into two knapsack // using memoization function findMaxWeight(curr, n, arr, capacity1, capacity2, memo) { // Base case: if all items have been considered if (curr >= n) return 0; // If the result is already computed for this // subproblem, return it if (memo[curr][capacity1][capacity2] !== -1) return memo[curr][capacity1][capacity2]; // Option 1: Don't take the current item let res = findMaxWeight(curr + 1, n, arr, capacity1, capacity2, memo); // Option 2: If the current item can be added to the // first knapsack, do it if (capacity1 >= arr[curr]) { let takeInFirst = arr[curr] + findMaxWeight(curr + 1, n, arr, capacity1 - arr[curr], capacity2, memo); res = Math.max(res, takeInFirst); } // Option 3: If the current item can be added to the // second knapsack, do it if (capacity2 >= arr[curr]) { let takeInSecond = arr[curr] + findMaxWeight(curr + 1, n, arr, capacity1, capacity2 - arr[curr], memo); res = Math.max(res, takeInSecond); } // Store the result in the memoization table and return // it memo[curr][capacity1][capacity2] = res; return res; } function maxWeight(arr, capacity1, capacity2) { let n = arr.length; // Create a memoization table with all values // initialized to -1 let memo = new Array(n); for (let i = 0; i < n; i++) { memo[i] = new Array(capacity1 + 1); for (let j = 0; j <= capacity1; j++) { memo[i][j] = new Array(capacity2 + 1).fill(-1); } } return findMaxWeight(0, n, arr, capacity1, capacity2, memo); } let arr = [ 8, 2, 3 ]; let capacity1 = 10; let capacity2 = 3; let res = maxWeight(arr, capacity1, capacity2); console.log(res); Using Tabulation - O(n*capacity1*capacity2) Time and O(n*capacity1*capacity2) Space
The approach is similar to the previous one. just instead of breaking down the problem recursively, we iteratively build up the solution by calculating in bottom-up manner.
So we will create 3D array dp of size (n + 1) x (capacity1 + 1) x (capacity2 + 1). Here, dp[i][j][k] represents the maximum weight that can be achieved by considering items from arr[0] to arr[i-1] with two knapsacks of remaining capacities j and k.
Base Case:
If no items are considered (i = 0), then no weight can be placed in either knapsack, so:
dp[0][j][k]=0 for all j, k
Recurrence Relation:
For each item i (1<=i<=n), we have three choices:
- Do not include item arr[i-1] in either knapsack
dp[i][j][k] = dp[i-1][j][k]
- Include item arr[i-1] in the first knapsack if its weight arr[i-1] is less than or equal to j:
dp[i][j][k] = max(dp[i][j][k], arr[i-1] + dp[i-1][j - arr[i-1]][k])
- Include item arr[i-1] in the second knapsack if its weight arr[i-1] is less than or equal to k:
dp[i][j][k] = max(dp[i][j][k], arr[i-1] + dp[i-1][j][k - arr[i-1]])
C++ // C++ program to find the largest subset of // the array that can fit into two knapsack // using tabulation #include <algorithm> #include <iostream> #include <vector> using namespace std; int maxWeight(vector<int> &arr, int capacity1, int capacity2) { int n = arr.size(); // Initialize a 3D DP array with dimensions (n+1) x (w1+1) x (w2+1) vector<vector<vector<int>>> dp(n + 1, vector<vector<int>> (capacity1 + 1, vector<int>(capacity2 + 1, 0))); // Fill the DP array iteratively for (int i = 1; i <= n; ++i) { int weight = arr[i - 1]; for (int j = 0; j <= capacity1; ++j) { for (int k = 0; k <= capacity2; ++k) { // Option 1: Don't take the current item dp[i][j][k] = dp[i - 1][j][k]; // Option 2: Take the current item in the // first knapsack, if possible if (j >= weight) { dp[i][j][k] = max(dp[i][j][k], weight + dp[i - 1][j - weight][k]); } // Option 3: Take the current item in the // second knapsack, if possible if (k >= weight) { dp[i][j][k] = max(dp[i][j][k], weight + dp[i - 1][j][k - weight]); } } } } return dp[n][capacity1][capacity2]; } int main() { vector<int> arr = {8, 2, 3}; int capacity1 = 10, capacity2 = 3; int res = maxWeight(arr, capacity1, capacity2); cout << res; return 0; } // Java program to find the largest subset of // the array that can fit into two knapsack // using tabulation import java.util.Arrays; import java.util.List; class GfG { static int maxWeight(List<Integer> arr, int capacity1, int capacity2) { int n = arr.size(); // Initialize a 3D DP array with dimensions (n+1) x // (w1+1) x (w2+1) int[][][] dp = new int[n + 1][capacity1 + 1][capacity2 + 1]; // Fill the DP array iteratively for (int i = 1; i <= n; i++) { int weight = arr.get(i - 1); for (int j = 0; j <= capacity1; j++) { for (int k = 0; k <= capacity2; k++) { // Option 1: Don't take the current item dp[i][j][k] = dp[i - 1][j][k]; // Option 2: Take the current item in // the first knapsack, if possible if (j >= weight) { dp[i][j][k] = Math.max( dp[i][j][k], weight + dp[i - 1][j - weight][k]); } // Option 3: Take the current item in // the second knapsack, if possible if (k >= weight) { dp[i][j][k] = Math.max( dp[i][j][k], weight + dp[i - 1][j][k - weight]); } } } } return dp[n][capacity1][capacity2]; } public static void main(String[] args) { List<Integer> arr = Arrays.asList(8, 2, 3); int capacity1 = 10, capacity2 = 3; int res=maxWeight(arr, capacity1, capacity2); System.out.println(res); } } # Python program to find the largest subset of # the array that can fit into two knapsack # using tabulation def maxWeight(arr, capacity1, capacity2): n = len(arr) # Initialize a 3D DP array with dimensions # (n+1) x (w1+1) x (w2+1) dp = [[[0 for _ in range(capacity2 + 1)] for _ in range(capacity1 + 1)] for _ in range(n + 1)] # Fill the DP array iteratively for i in range(1, n + 1): weight = arr[i - 1] for j in range(capacity1 + 1): for k in range(capacity2 + 1): # Option 1: Don't take the current item dp[i][j][k] = dp[i - 1][j][k] # Option 2: Take the current item in the # first knapsack, if possible if j >= weight: dp[i][j][k] = max(dp[i][j][k], weight + dp[i - 1][j - weight][k]) # Option 3: Take the current item in the # second knapsack, if possible if k >= weight: dp[i][j][k] = max(dp[i][j][k], weight + dp[i - 1][j][k - weight]) return dp[n][capacity1][capacity2] arr = [8, 2, 3] capacity1 = 10 capacity2 = 3 res = maxWeight(arr, capacity1, capacity2) print(res)
// C# program to find the largest subset of // the array that can fit into two knapsack // using tabulation using System; using System.Collections.Generic; class GfG { static int maxWeight(List<int> arr, int capacity1, int capacity2) { int n = arr.Count; // Initialize a 3D DP array with dimensions (n+1) x // (w1+1) x (w2+1) int[, , ] dp = new int[n + 1, capacity1 + 1, capacity2 + 1]; // Fill the DP array iteratively for (int i = 1; i <= n; i++) { int weight = arr[i - 1]; for (int j = 0; j <= capacity1; j++) { for (int k = 0; k <= capacity2; k++) { // Option 1: Don't take the current item dp[i, j, k] = dp[i - 1, j, k]; // Option 2: Take the current item in // the first knapsack, if possible if (j >= weight) { dp[i, j, k] = Math.Max( dp[i, j, k], weight + dp[i - 1, j - weight, k]); } // Option 3: Take the current item in // the second knapsack, if possible if (k >= weight) { dp[i, j, k] = Math.Max( dp[i, j, k], weight + dp[i - 1, j, k - weight]); } } } } return dp[n, capacity1, capacity2]; } static void Main() { List<int> arr = new List<int>{ 8, 2, 3 }; int capacity1 = 10, capacity2 = 3; int res = maxWeight(arr, capacity1, capacity2); Console.WriteLine(res); } } // JavaScript program to find the largest subset of // the array that can fit into two knapsack // using tabulation function maxWeight(arr, capacity1, capacity2) { const n = arr.length; // Initialize a 3D DP array with dimensions (n+1) x // (capacity1+1) x (capacity2+1) const dp = Array.from( {length : n + 1}, () => Array.from({length : capacity1 + 1}, () => Array(capacity2 + 1).fill(0))); // Fill the DP array iteratively for (let i = 1; i <= n; i++) { const weight = arr[i - 1]; for (let j = 0; j <= capacity1; j++) { for (let k = 0; k <= capacity2; k++) { // Option 1: Don't take the current item dp[i][j][k] = dp[i - 1][j][k]; // Option 2: Take the current item in the // first knapsack, if possible if (j >= weight) { dp[i][j][k] = Math.max( dp[i][j][k], weight + dp[i - 1][j - weight][k]); } // Option 3: Take the current item in the // second knapsack, if possible if (k >= weight) { dp[i][j][k] = Math.max( dp[i][j][k], weight + dp[i - 1][j][k - weight]); } } } } return dp[n][capacity1][capacity2]; } const arr = [ 8, 2, 3 ]; const capacity1 = 10; const capacity2= 3; const res = maxWeight(arr, capacity1, capacity2); console.log(res); Similar Reads
Introduction to Knapsack Problem, its Types and How to solve them The Knapsack problem is an example of the combinational optimization problem. This problem is also commonly known as the "Rucksack Problem". The name of the problem is defined from the maximization problem as mentioned below:Given a bag with maximum weight capacity of W and a set of items, each havi
6 min read
Fractional Knapsack
0/1 Knapsack
0/1 Knapsack ProblemGiven n items where each item has some weight and profit associated with it and also given a bag with capacity W, [i.e., the bag can hold at most W weight in it]. The task is to put the items into the bag such that the sum of profits associated with them is the maximum possible. Note: The constraint
15+ min read
Printing Items in 0/1 KnapsackGiven weights and values of n items, put these items in a knapsack of capacity W to get the maximum total value in the knapsack. In other words, given two integer arrays, val[0..n-1] and wt[0..n-1] represent values and weights associated with n items respectively. Also given an integer W which repre
12 min read
0/1 Knapsack Problem to print all possible solutionsGiven weights and profits of N items, put these items in a knapsack of capacity W. The task is to print all possible solutions to the problem in such a way that there are no remaining items left whose weight is less than the remaining capacity of the knapsack. Also, compute the maximum profit.Exampl
10 min read
0-1 knapsack queriesGiven an integer array W[] consisting of weights of the items and some queries consisting of capacity C of knapsack, for each query find maximum weight we can put in the knapsack. Value of C doesn't exceed a certain integer C_MAX. Examples: Input: W[] = {3, 8, 9} q = {11, 10, 4} Output: 11 9 3 If C
12 min read
0/1 Knapsack using Branch and BoundGiven two arrays v[] and w[] that represent values and weights associated with n items respectively. Find out the maximum value subset(Maximum Profit) of v[] such that the sum of the weights of this subset is smaller than or equal to Knapsack capacity W.Note: The constraint here is we can either put
15+ min read
0/1 Knapsack using Least Cost Branch and BoundGiven N items with weights W[0..n-1], values V[0..n-1] and a knapsack with capacity C, select the items such that:Â Â The sum of weights taken into the knapsack is less than or equal to C.The sum of values of the items in the knapsack is maximum among all the possible combinations.Examples:Â Â Input:
15+ min read
Unbounded Fractional Knapsack Given the weights and values of n items, the task is to put these items in a knapsack of capacity W to get the maximum total value in the knapsack, we can repeatedly put the same item and we can also put a fraction of an item. Examples: Input: val[] = {14, 27, 44, 19}, wt[] = {6, 7, 9, 8}, W = 50 Ou
5 min read
Unbounded Knapsack (Repetition of items allowed) Given a knapsack weight, say capacity and a set of n items with certain value vali and weight wti, The task is to fill the knapsack in such a way that we can get the maximum profit. This is different from the classical Knapsack problem, here we are allowed to use an unlimited number of instances of
15+ min read
Unbounded Knapsack (Repetition of items allowed) | Efficient Approach Given an integer W, arrays val[] and wt[], where val[i] and wt[i] are the values and weights of the ith item, the task is to calculate the maximum value that can be obtained using weights not exceeding W. Note: Each weight can be included multiple times. Examples: Input: W = 4, val[] = {6, 18}, wt[]
8 min read
Double Knapsack | Dynamic Programming Given an array arr[] containing the weight of 'n' distinct items, and two knapsacks that can withstand capactiy1 and capacity2 weights, the task is to find the sum of the largest subset of the array 'arr', that can be fit in the two knapsacks. It's not allowed to break any items in two, i.e. an item
15+ min read
Some Problems of Knapsack problem
Partition a Set into Two Subsets of Equal SumGiven an array arr[], the task is to check if it can be partitioned into two parts such that the sum of elements in both parts is the same.Note: Each element is present in either the first subset or the second subset, but not in both.Examples: Input: arr[] = [1, 5, 11, 5]Output: true Explanation: Th
15+ min read
Count of subsets with sum equal to targetGiven an array arr[] of length n and an integer target, the task is to find the number of subsets with a sum equal to target.Examples: Input: arr[] = [1, 2, 3, 3], target = 6 Output: 3 Explanation: All the possible subsets are [1, 2, 3], [1, 2, 3] and [3, 3]Input: arr[] = [1, 1, 1, 1], target = 1 Ou
15+ min read
Length of longest subset consisting of A 0s and B 1s from an array of stringsGiven an array arr[] consisting of binary strings, and two integers a and b, the task is to find the length of the longest subset consisting of at most a 0s and b 1s.Examples:Input: arr[] = ["1" ,"0" ,"0001" ,"10" ,"111001"], a = 5, b = 3Output: 4Explanation: One possible way is to select the subset
15+ min read
Breaking an Integer to get Maximum ProductGiven a number n, the task is to break n in such a way that multiplication of its parts is maximized. Input : n = 10Output: 36Explanation: 10 = 4 + 3 + 3 and 4 * 3 * 3 = 36 is the maximum possible product. Input: n = 8Output: 18Explanation: 8 = 2 + 3 + 3 and 2 * 3 * 3 = 18 is the maximum possible pr
15+ min read
Coin Change - Minimum Coins to Make SumGiven an array of coins[] of size n and a target value sum, where coins[i] represent the coins of different denominations. You have an infinite supply of each of the coins. The task is to find the minimum number of coins required to make the given value sum. If it is not possible to form the sum usi
15+ min read
Coin Change - Count Ways to Make SumGiven an integer array of coins[] of size n representing different types of denominations and an integer sum, the task is to count all combinations of coins to make a given value sum. Note: Assume that you have an infinite supply of each type of coin. Examples: Input: sum = 4, coins[] = [1, 2, 3]Out
15+ min read
Maximum sum of values of N items in 0-1 Knapsack by reducing weight of at most K items in halfGiven weights and values of N items and the capacity W of the knapsack. Also given that the weight of at most K items can be changed to half of its original weight. The task is to find the maximum sum of values of N items that can be obtained such that the sum of weights of items in knapsack does no
15+ min read