Open In App
Related Articles

# Double Knapsack | Dynamic Programming

Given an array ‘arr’ containing the weight of ‘N’ distinct items, and two knapsacks that can withstand ‘W1’ and ‘W2’ 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}
W1 = 10, W2 = 3
Output : 13
First and third objects go in the first knapsack. The second object goes in the second knapsack. Thus, the total weight becomes 13.
Input : arr[] = {8, 5, 3}
W1 = 10, W2 = 3
Output : 11

Solution:
A recursive solution is to try out all the possible ways of filling the two knapsacks and choose the one giving the maximum weight.
To optimize the above idea, we need to determine the states of DP, that we will build up our solution upon. After little observation, we can determine that this can be represented in three states (i, w1_r, w2_r). Here ‘i’ means the index of the element we are trying to store, w1_r means the remaining space of the first knapsack, and w2_r means the remaining space of the second knapsack. Thus, the problem can be solved using a 3-dimensional dynamic-programming with a recurrence relation

`DP[i][w1_r][w2_r] = max( DP[i + 1][w1_r][w2_r],                    arr[i] + DP[i + 1][w1_r - arr[i]][w2_r],                    arr[i] + DP[i + 1][w1_r][w2_r - arr[i]])`

The explanation for the above recurrence relation is as follows:

For each ‘i’, we can either:

1. Don’t select the item ‘i’.
2. Fill the item ‘i’ in first knapsack.
3. Fill the item ‘i’ in second knapsack.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the above approach``#include ``#define maxN 31``#define maxW 31``using` `namespace` `std;` `// 3D array to store``// states of DP``int` `dp[maxN][maxW][maxW];` `// w1_r represents remaining capacity of 1st knapsack``// w2_r represents remaining capacity of 2nd knapsack``// i represents index of the array arr we are working on``int` `maxWeight(``int``* arr, ``int` `n, ``int` `w1_r, ``int` `w2_r, ``int` `i)``{``    ``// Base case``    ``if` `(i == n)``        ``return` `0;``    ``if` `(dp[i][w1_r][w2_r] != -1)``        ``return` `dp[i][w1_r][w2_r];` `    ``// Variables to store the result of three``    ``// parts of recurrence relation``    ``int` `fill_w1 = 0, fill_w2 = 0, fill_none = 0;` `    ``if` `(w1_r >= arr[i])``        ``fill_w1 = arr[i] +``         ``maxWeight(arr, n, w1_r - arr[i], w2_r, i + 1);` `    ``if` `(w2_r >= arr[i])``        ``fill_w2 = arr[i] +``         ``maxWeight(arr, n, w1_r, w2_r - arr[i], i + 1);` `    ``fill_none = maxWeight(arr, n, w1_r, w2_r, i + 1);` `    ``// Store the state in the 3D array``    ``dp[i][w1_r][w2_r] = max(fill_none, max(fill_w1, fill_w2));` `    ``return` `dp[i][w1_r][w2_r];``}` `// Driver code``int` `main()``{``    ``// Input array``    ``int` `arr[] = { 8, 2, 3 };` `    ``// Initializing the array with -1``    ``memset``(dp, -1, ``sizeof``(dp));` `    ``// Number of elements in the array``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``// Capacity of knapsacks``    ``int` `w1 = 10, w2 = 3;` `    ``// Function to be called``    ``cout << maxWeight(arr, n, w1, w2, 0);``    ``return` `0;``}`

## Java

 `// Java implementation of the above approach` `class` `GFG``{``    ``static` `int` `maxN = ``31``;``    ``static` `int` `maxW = ``31``;` `    ``// 3D array to store``    ``// states of DP``    ``static` `int` `dp [][][] = ``new` `int``[maxN][maxW][maxW];``    ` `    ``// w1_r represents remaining capacity of 1st knapsack``    ``// w2_r represents remaining capacity of 2nd knapsack``    ``// i represents index of the array arr we are working on``    ``static` `int` `maxWeight(``int` `arr [] , ``int` `n, ``int` `w1_r, ``int` `w2_r, ``int` `i)``    ``{``        ``// Base case``        ``if` `(i == n)``            ``return` `0``;``        ``if` `(dp[i][w1_r][w2_r] != -``1``)``            ``return` `dp[i][w1_r][w2_r];``    ` `        ``// Variables to store the result of three``        ``// parts of recurrence relation``        ``int` `fill_w1 = ``0``, fill_w2 = ``0``, fill_none = ``0``;``    ` `        ``if` `(w1_r >= arr[i])``            ``fill_w1 = arr[i] +``            ``maxWeight(arr, n, w1_r - arr[i], w2_r, i + ``1``);``    ` `        ``if` `(w2_r >= arr[i])``            ``fill_w2 = arr[i] +``            ``maxWeight(arr, n, w1_r, w2_r - arr[i], i + ``1``);``    ` `        ``fill_none = maxWeight(arr, n, w1_r, w2_r, i + ``1``);``    ` `        ``// Store the state in the 3D array``        ``dp[i][w1_r][w2_r] = Math.max(fill_none, Math.max(fill_w1, fill_w2));``    ` `        ``return` `dp[i][w1_r][w2_r];``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `main (String[] args)``    ``{``    ` `        ``// Input array``        ``int` `arr[] = { ``8``, ``2``, ``3` `};``    ` `        ``// Initializing the array with -1``        ` `        ``for` `(``int` `i = ``0``; i < maxN ; i++)``            ``for` `(``int` `j = ``0``; j < maxW ; j++)``                ``for` `(``int` `k = ``0``; k < maxW ; k++)``                        ``dp[i][j][k] = -``1``;``        ` `        ``// Number of elements in the array``        ``int` `n = arr.length;``    ` `        ``// Capacity of knapsacks``        ``int` `w1 = ``10``, w2 = ``3``;``    ` `        ``// Function to be called``        ``System.out.println(maxWeight(arr, n, w1, w2, ``0``));``    ``}``}` `// This code is contributed by ihritik`

## Python3

 `# Python3 implementation of the above approach` `# w1_r represents remaining capacity of 1st knapsack``# w2_r represents remaining capacity of 2nd knapsack``# i represents index of the array arr we are working on``def` `maxWeight(arr, n, w1_r, w2_r, i):` `    ``# Base case``    ``if` `i ``=``=` `n:``        ``return` `0``    ``if` `dp[i][w1_r][w2_r] !``=` `-``1``:``        ``return` `dp[i][w1_r][w2_r]` `    ``# Variables to store the result of three``    ``# parts of recurrence relation``    ``fill_w1, fill_w2, fill_none ``=` `0``, ``0``, ``0` `    ``if` `w1_r >``=` `arr[i]:``        ``fill_w1 ``=` `arr[i] ``+` `maxWeight(arr, n, w1_r ``-` `arr[i],``                                             ``w2_r, i ``+` `1``)` `    ``if` `w2_r >``=` `arr[i]:``        ``fill_w2 ``=` `arr[i] ``+` `maxWeight(arr, n, w1_r,``                                     ``w2_r ``-` `arr[i], i ``+` `1``)` `    ``fill_none ``=` `maxWeight(arr, n, w1_r, w2_r, i ``+` `1``)` `    ``# Store the state in the 3D array``    ``dp[i][w1_r][w2_r] ``=` `max``(fill_none, ``max``(fill_w1,``                                           ``fill_w2))` `    ``return` `dp[i][w1_r][w2_r]`  `# Driver code``if` `__name__ ``=``=` `"__main__"``:` `    ``# Input array``    ``arr ``=` `[``8``, ``2``, ``3``]``    ``maxN, maxW ``=` `31``, ``31``    ` `    ``# 3D array to store``    ``# states of DP``    ``dp ``=` `[[[``-``1``] ``*` `maxW] ``*` `maxW] ``*` `maxN``    ` `    ``# Number of elements in the array``    ``n ``=` `len``(arr)` `    ``# Capacity of knapsacks``    ``w1, w2 ``=` `10``, ``3` `    ``# Function to be called``    ``print``(maxWeight(arr, n, w1, w2, ``0``))``    ` `# This code is contributed by Rituraj Jain`

## C#

 `// C# implementation of the above approach``using` `System;` `class` `GFG``{``    ``static` `int` `maxN = 31;``    ``static` `int` `maxW = 31;` `    ``// 3D array to store``    ``// states of DP``    ``static` `int` `[ , , ] dp = ``new` `int``[maxN, maxW, maxW];``    ` `    ``// w1_r represents remaining capacity of 1st knapsack``    ``// w2_r represents remaining capacity of 2nd knapsack``    ``// i represents index of the array arr we are working on``    ``static` `int` `maxWeight(``int` `[] arr, ``int` `n, ``int` `w1_r,``                                    ``int` `w2_r, ``int` `i)``    ``{``        ``// Base case``        ``if` `(i == n)``            ``return` `0;``        ``if` `(dp[i ,w1_r, w2_r] != -1)``            ``return` `dp[i, w1_r, w2_r];``    ` `        ``// Variables to store the result of three``        ``// parts of recurrence relation``        ``int` `fill_w1 = 0, fill_w2 = 0, fill_none = 0;``    ` `        ``if` `(w1_r >= arr[i])``            ``fill_w1 = arr[i] +``            ``maxWeight(arr, n, w1_r - arr[i], w2_r, i + 1);``    ` `        ``if` `(w2_r >= arr[i])``            ``fill_w2 = arr[i] +``            ``maxWeight(arr, n, w1_r, w2_r - arr[i], i + 1);``    ` `        ``fill_none = maxWeight(arr, n, w1_r, w2_r, i + 1);``    ` `        ``// Store the state in the 3D array``        ``dp[i, w1_r, w2_r] = Math.Max(fill_none, Math.Max(fill_w1, fill_w2));``    ` `        ``return` `dp[i, w1_r, w2_r];``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `Main ()``    ``{``    ` `        ``// Input array``        ``int` `[] arr = { 8, 2, 3 };``    ` `        ``// Initializing the array with -1``        ` `        ``for` `(``int` `i = 0; i < maxN ; i++)``            ``for` `(``int` `j = 0; j < maxW ; j++)``                ``for` `(``int` `k = 0; k < maxW ; k++)``                        ``dp[i, j, k] = -1;``        ` `        ``// Number of elements in the array``        ``int` `n = arr.Length;``    ` `        ``// Capacity of knapsacks``        ``int` `w1 = 10, w2 = 3;``    ` `        ``// Function to be called``        ``Console.WriteLine(maxWeight(arr, n, w1, w2, 0));``    ``}``}` `// This code is contributed by ihritik`

## Javascript

 ``

Output

```13

```

Time complexity: O(N*W1*W2)
Auxiliary Space: O(N*W1*W2))

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 3-D DP to store the solution of the subproblems.
• Initialize the DP with base cases if (i == 0) then dp[i][w1_r][w2_r] = 0
• Now Iterate over subproblems to get the value of current problem form previous computation of subproblems stored in DP
• Return the final solution stored in return dp[n][w1][w2].

Implementation :

## C++

 `// C++ implementation of the tabulation approach``#include ``#define maxN 31``#define maxW 31``using` `namespace` `std;` `// 3D array to store``// states of DP``int` `dp[maxN][maxW][maxW];` `// Function to calculate``// maximum weight that can be put``// into the knapsacks``int` `maxWeight(``int``* arr, ``int` `n, ``int` `w1, ``int` `w2)``{``    ``// Iterate over all possible states``    ``for` `(``int` `i = 0; i <= n; i++)``    ``{``        ``for` `(``int` `w1_r = 0; w1_r <= w1; w1_r++)``        ``{``            ``for` `(``int` `w2_r = 0; w2_r <= w2; w2_r++)``            ``{``            ``// Base case   ``            ``if` `(i == 0)``            ``dp[i][w1_r][w2_r] = 0;``            ``// If the current item can be put in``            ``// the first knapsack``            ``else` `if` `(arr[i - 1] <= w1_r && arr[i - 1] <= w2_r)``                ``dp[i][w1_r][w2_r] =``                ``max(arr[i - 1] + dp[i - 1][w1_r - arr[i - 1]][w2_r],``                    ``max(arr[i - 1] + dp[i - 1][w1_r][w2_r - arr[i - 1]],``                        ``dp[i - 1][w1_r][w2_r]));` `            ``// If the current item can be put in``            ``// the second knapsack``            ``else` `if` `(arr[i - 1] <= w2_r)``                ``dp[i][w1_r][w2_r] = max(arr[i - 1] + dp[i - 1][w1_r][w2_r - arr[i - 1]],``                                    ``dp[i - 1][w1_r][w2_r]);` `            ``// If the current item can be put in``            ``// the first knapsack``            ``else` `if` `(arr[i - 1] <= w1_r)``                ``dp[i][w1_r][w2_r] = max(arr[i - 1] + dp[i - 1][w1_r - arr[i - 1]][w2_r],``                                    ``dp[i - 1][w1_r][w2_r]);` `            ``// If the current item can not be put in``            ``// either of the knapsacks``            ``else``                ``dp[i][w1_r][w2_r] = dp[i - 1][w1_r][w2_r];``            ``}``        ``}``    ``}``    ` `    ``// Return the maximum weight that can be put``    ``// into the knapsacks``    ``return` `dp[n][w1][w2];``}` `// Driver code``int` `main()``{``    ``// Input array``    ``int` `arr[] = { 8, 2, 3 };``    ``// Number of elements in the array``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ` `    ``// Capacity of knapsacks``    ``int` `w1 = 10, w2 = 3;``    ` `    ``// Function to be called``    ``cout << maxWeight(arr, n, w1, w2);``    ``return` `0;``}`

## Java

 `import` `java.util.*;` `public` `class` `Main``{``  ` `    ``// 3D array to store states of DP``    ``static` `int``[][][] dp = ``new` `int``[``31``][``31``][``31``];` `    ``// Function to calculate maximum weight``  ``// that can be put into the knapsacks``    ``public` `static` `int` `maxWeight(``int``[] arr, ``int` `n,``                                ``int` `w1, ``int` `w2)``    ``{``      ` `        ``// Iterate over all possible states``        ``for` `(``int` `i = ``0``; i <= n; i++) {``            ``for` `(``int` `w1_r = ``0``; w1_r <= w1; w1_r++) {``                ``for` `(``int` `w2_r = ``0``; w2_r <= w2; w2_r++) {``                    ``// Base case``                    ``if` `(i == ``0``) {``                        ``dp[i][w1_r][w2_r] = ``0``;``                    ``}``                  ` `                    ``// If the current item can be put in the first knapsack``                    ``else` `if` `(arr[i - ``1``] <= w1_r && arr[i - ``1``] <= w2_r) {``                        ``dp[i][w1_r][w2_r] = Math.max(``                                ``arr[i - ``1``] + dp[i - ``1``][w1_r - arr[i - ``1``]][w2_r],``                                ``Math.max(arr[i - ``1``] + dp[i - ``1``][w1_r][w2_r - arr[i - ``1``]], dp[i - ``1``][w1_r][w2_r]));``                    ``}``                  ` `                    ``// If the current item can be put in the second knapsack``                    ``else` `if` `(arr[i - ``1``] <= w2_r) {``                        ``dp[i][w1_r][w2_r] = Math.max(arr[i - ``1``] + dp[i - ``1``][w1_r][w2_r - arr[i - ``1``]],``                                ``dp[i - ``1``][w1_r][w2_r]);``                    ``}``                  ` `                    ``// If the current item can be put in the first knapsack``                    ``else` `if` `(arr[i - ``1``] <= w1_r) {``                        ``dp[i][w1_r][w2_r] = Math.max(arr[i - ``1``] + dp[i - ``1``][w1_r - arr[i - ``1``]][w2_r],``                                ``dp[i - ``1``][w1_r][w2_r]);``                    ``}``                  ` `                    ``// If the current item can not be put in either of the knapsacks``                    ``else` `{``                        ``dp[i][w1_r][w2_r] = dp[i - ``1``][w1_r][w2_r];``                    ``}``                ``}``            ``}``        ``}` `        ``// Return the maximum weight that can be put into the knapsacks``        ``return` `dp[n][w1][w2];``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``      ` `        ``// Input array``        ``int``[] arr = { ``8``, ``2``, ``3` `};``      ` `        ``// Number of elements in the array``        ``int` `n = arr.length;` `        ``// Capacity of knapsacks``        ``int` `w1 = ``10``, w2 = ``3``;` `        ``// Function to be called``        ``System.out.println(maxWeight(arr, n, w1, w2));``    ``}``}`

## Python3

 `# Constants for maximum values``maxN ``=` `31``maxW ``=` `31` `# 3D array to store states of DP``dp ``=` `[[[``0` `for` `_ ``in` `range``(maxW)] ``for` `_ ``in` `range``(maxW)] ``for` `_ ``in` `range``(maxN)]` `# Function to calculate maximum weight that can be put into the knapsacks``def` `maxWeight(arr, n, w1, w2):``    ``# Iterate over all possible states``    ``for` `i ``in` `range``(n ``+` `1``):``        ``for` `w1_r ``in` `range``(w1 ``+` `1``):``            ``for` `w2_r ``in` `range``(w2 ``+` `1``):``                ``# Base case``                ``if` `i ``=``=` `0``:``                    ``dp[i][w1_r][w2_r] ``=` `0``                ``# If the current item can be put in both knapsacks``                ``elif` `arr[i ``-` `1``] <``=` `w1_r ``and` `arr[i ``-` `1``] <``=` `w2_r:``                    ``dp[i][w1_r][w2_r] ``=` `max``(``                        ``arr[i ``-` `1``] ``+` `dp[i ``-` `1``][w1_r ``-` `arr[i ``-` `1``]][w2_r],``                        ``max``(``                            ``arr[i ``-` `1``] ``+` `dp[i ``-` `1``][w1_r][w2_r ``-` `arr[i ``-` `1``]],``                            ``dp[i ``-` `1``][w1_r][w2_r]``                        ``)``                    ``)``                ``# If the current item can be put in the second knapsack``                ``elif` `arr[i ``-` `1``] <``=` `w2_r:``                    ``dp[i][w1_r][w2_r] ``=` `max``(``                        ``arr[i ``-` `1``] ``+` `dp[i ``-` `1``][w1_r][w2_r ``-` `arr[i ``-` `1``]],``                        ``dp[i ``-` `1``][w1_r][w2_r]``                    ``)``                ``# If the current item can be put in the first knapsack``                ``elif` `arr[i ``-` `1``] <``=` `w1_r:``                    ``dp[i][w1_r][w2_r] ``=` `max``(``                        ``arr[i ``-` `1``] ``+` `dp[i ``-` `1``][w1_r ``-` `arr[i ``-` `1``]][w2_r],``                        ``dp[i ``-` `1``][w1_r][w2_r]``                    ``)``                ``# If the current item cannot be put in either knapsack``                ``else``:``                    ``dp[i][w1_r][w2_r] ``=` `dp[i ``-` `1``][w1_r][w2_r]` `    ``# Return the maximum weight that can be put into the knapsacks``    ``return` `dp[n][w1][w2]` `# Driver code``if` `__name__ ``=``=` `"__main__"``:``    ``# Input array``    ``arr ``=` `[``8``, ``2``, ``3``]``    ``# Number of elements in the array``    ``n ``=` `len``(arr)` `    ``# Capacity of knapsacks``    ``w1 ``=` `10``    ``w2 ``=` `3` `    ``# Function call``    ``print``(maxWeight(arr, n, w1, w2))`

## C#

 `using` `System;` `public` `class` `KnapsackProblem``{``    ``// Function to calculate``    ``// maximum weight that can be put``    ``// into the knapsacks``    ``public` `static` `int` `MaxWeight(``int``[] arr, ``int` `n, ``int` `w1, ``int` `w2)``    ``{``        ``// 3D array to store``        ``// states of DP``        ``int``[,,] dp = ``new` `int``[n + 1, w1 + 1, w2 + 1];` `        ``// Iterate over all possible states``        ``for` `(``int` `i = 0; i <= n; i++)``        ``{``            ``for` `(``int` `w1_r = 0; w1_r <= w1; w1_r++)``            ``{``                ``for` `(``int` `w2_r = 0; w2_r <= w2; w2_r++)``                ``{``                    ``// Base case   ``                    ``if` `(i == 0)``                        ``dp[i, w1_r, w2_r] = 0;` `                    ``// If the current item can be put in``                    ``// the first knapsack``                    ``else` `if` `(arr[i - 1] <= w1_r && arr[i - 1] <= w2_r)``                        ``dp[i, w1_r, w2_r] =``                            ``Math.Max(arr[i - 1] + dp[i - 1, w1_r - arr[i - 1], w2_r],``                                     ``Math.Max(arr[i - 1] + dp[i - 1, w1_r, w2_r - arr[i - 1]],``                                              ``dp[i - 1, w1_r, w2_r]));` `                    ``// If the current item can be put in``                    ``// the second knapsack``                    ``else` `if` `(arr[i - 1] <= w2_r)``                        ``dp[i, w1_r, w2_r] = Math.Max(arr[i - 1] + dp[i - 1, w1_r, w2_r - arr[i - 1]],``                                                      ``dp[i - 1, w1_r, w2_r]);` `                    ``// If the current item can be put in``                    ``// the first knapsack``                    ``else` `if` `(arr[i - 1] <= w1_r)``                        ``dp[i, w1_r, w2_r] = Math.Max(arr[i - 1] + dp[i - 1, w1_r - arr[i - 1], w2_r],``                                                      ``dp[i - 1, w1_r, w2_r]);` `                    ``// If the current item can not be put in``                    ``// either of the knapsacks``                    ``else``                        ``dp[i, w1_r, w2_r] = dp[i - 1, w1_r, w2_r];``                ``}``            ``}``        ``}` `        ``// Return the maximum weight that can be put``        ``// into the knapsacks``        ``return` `dp[n, w1, w2];``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``// Input array``        ``int``[] arr = { 8, 2, 3 };``        ``// Number of elements in the array``        ``int` `n = arr.Length;` `        ``// Capacity of knapsacks``        ``int` `w1 = 10, w2 = 3;` `        ``// Function to be called``        ``Console.WriteLine(MaxWeight(arr, n, w1, w2));``    ``}``}`

## Javascript

 `const maxN = 31;``const maxW = 31;` `// 3D array to store states of DP``const dp = ``new` `Array(maxN).fill(``null``).map(() =>``           ``new` `Array(maxW).fill(``null``).map(() =>``           ``new` `Array(maxW).fill(0)));` `// Function to calculate maximum weight that can be put into the knapsacks``function` `maxWeight(arr, n, w1, w2) {``    ``// Iterate over all possible states``    ``for` `(let i = 0; i <= n; i++) {``        ``for` `(let w1_r = 0; w1_r <= w1; w1_r++) {``            ``for` `(let w2_r = 0; w2_r <= w2; w2_r++) {``            ` `                ``// Base case``                ``if` `(i === 0)``                ``{``                    ``dp[i][w1_r][w2_r] = 0;``                ``}``                ``else` `if` `(arr[i - 1] <= w1_r && arr[i - 1] <= w2_r)``                ``{``                    ``dp[i][w1_r][w2_r] =``                        ``Math.max(``                            ``arr[i - 1] + dp[i - 1][w1_r - arr[i - 1]][w2_r],``                            ``Math.max(``                                ``arr[i - 1] + dp[i - 1][w1_r][w2_r - arr[i - 1]],``                                ``dp[i - 1][w1_r][w2_r]``                            ``)``                        ``);``                ``}``                ``else` `if` `(arr[i - 1] <= w2_r)``                ``{``                    ``dp[i][w1_r][w2_r] = Math.max(``                        ``arr[i - 1] + dp[i - 1][w1_r][w2_r - arr[i - 1]],``                        ``dp[i - 1][w1_r][w2_r]``                    ``);``                ``}``                ``else` `if` `(arr[i - 1] <= w1_r)``                ``{``                    ``dp[i][w1_r][w2_r] = Math.max(``                        ``arr[i - 1] + dp[i - 1][w1_r - arr[i - 1]][w2_r],``                        ``dp[i - 1][w1_r][w2_r]``                    ``);``                ``}``                ``else``                ``{``                    ``dp[i][w1_r][w2_r] = dp[i - 1][w1_r][w2_r];``                ``}``            ``}``        ``}``    ``}` `    ``// Return the maximum weight that can be put into the knapsacks``    ``return` `dp[n][w1][w2];``}` `// Driver code` `// Input array``const arr = [8, 2, 3];``    ` `// Number of elements in the array``const n = arr.length;` `// Capacity of knapsacks``const w1 = 10, w2 = 3;` `// Function to be called``console.log(maxWeight(arr, n, w1, w2));`

Output

```13

```

Time complexity: O(N*W1*W2)
Auxiliary Space: O(N*W1*W2))