 Open in App
Not now

# Maximize sum of subsets from two arrays having no consecutive values

• Difficulty Level : Hard
• Last Updated : 07 Feb, 2022

Given two arrays arr1[] and arr2[] of equal length, the task is to find the maximum sum of any subset possible by selecting elements from both the arrays such that no two elements in the subset should be consecutive.

Examples:

Input: arr1[] = {-1, -2, 4, -4, 5}, arr2[] = {-1, -2, -3, 4, 10}
Output: 14
Explanation:
Required subset {4, 10}. Therefore, sum = 4 + 10 = 14.

Input: arr1[] = {2, 5, 4, 2000}, arr2[] = {-2000, 100, 23, 40}
Output: 2100

Naive Approach: The simplest approach is to generate all possible subsets from both the given arrays such that no two adjacent elements are consecutive and calculate the sum of each subset. Finally, print the maximum sum possible.
Time Complexity: O(N*2N)
Auxiliary Space: O(2N)

Efficient Approach: The above approach can be optimized using Dynamic Programming. Follow the steps below to solve the problem:

• Initialize an auxiliary array dp[] of size N.
• Here, dp[i] stores the maximum possible sum of a subset from both the arrays such that no two elements are consecutive.
• Declare a function maximumSubsetSum():
• Base Cases:
• dp = max(arr1, arr2).
• dp = max(max(arr1, arr2), max(arr1, arr2)).
• For all other cases, following three conditions arise:
• dp[i] = max(arr1[i], arr2[i], arr1[i] + dp[i – 2], arr2[i] + dp[i – 2], dp[i – 1]).
• Finally, print dp[N] as the required answer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to calculate maximum subset sum``void` `maximumSubsetSum(``int` `arr1[],``int` `arr2[], ``int` `length)``{` `    ``// Initialize array to store dp states``    ``int` `dp[length+1];` `    ``// Base Cases``    ``if` `(length == 1)``    ``{``        ``cout << (max(arr1, arr2));``        ``return``;``    ``}` `    ``if` `(length == 2)``    ``{``        ``cout << (max(max(arr1, arr2), max(arr1, arr2)));``        ``return``;``    ``}``    ``else``    ``{` `        ``// Pre initializing for dp & dp``        ``dp = max(arr1, arr2);``        ``dp = max(max(arr1, arr2), max(arr1, arr2));` `        ``int` `index = 2;``        ``while` `(index < length)``        ``{` `            ``// Calculating dp[index] based on``            ``// above formula``            ``dp[index] = max(max(arr1[index], arr2[index]),``                ``max(max(arr1[index] + dp[index - 2],``                        ``arr2[index] + dp[index - 2]),``                    ``dp[index - 1]));``            ``++index;``        ``}` `        ``// Print maximum subset sum``        ``cout<<(dp[length - 1]);``    ``}``}` `// Driver Code``int` `main()``{``  ` `  ``// Given arrays``  ``int` `arr1[] = { -1, -2, 4, -4, 5 };``  ``int` `arr2[] = { -1, -2, -3, 4, 10 };` `  ``// Length of the array``  ``int` `length = 5;``  ``maximumSubsetSum(arr1, arr2, length);``  ``return` `0;``}` `// This code is contributed by mohit kumar 29`

## Java

 `// Java program for the above approach` `import` `java.io.*;``import` `java.util.*;``class` `GFG {` `    ``// Function to calculate maximum subset sum``    ``static` `void` `maximumSubsetSum(``int` `arr1[],``                                 ``int` `arr2[],``                                 ``int` `length)``    ``{` `        ``// Initialize array to store dp states``        ``int` `dp[] = ``new` `int``[length + ``1``];` `        ``// Base Cases``        ``if` `(length == ``1``) {``            ``System.out.print(``                ``Math.max(arr1[``0``], arr2[``0``]));``            ``return``;``        ``}` `        ``if` `(length == ``2``) {``            ``System.out.print(``                ``Math.max(``                    ``Math.max(arr1[``1``], arr2[``1``]),``                    ``Math.max(arr1[``0``], arr2[``0``])));``            ``return``;``        ``}``        ``else` `{` `            ``// Pre initializing for dp & dp``            ``dp[``0``] = Math.max(arr1[``0``], arr2[``0``]);``            ``dp[``1``] = Math.max(``                ``Math.max(arr1[``1``], arr2[``1``]),``                ``Math.max(arr1[``0``], arr2[``0``]));` `            ``int` `index = ``2``;``            ``while` `(index < length) {` `                ``// Calculating dp[index] based on``                ``// above formula``                ``dp[index] = Math.max(``                    ``Math.max(arr1[index], arr2[index]),``                    ``Math.max(``                        ``Math.max(``                            ``arr1[index] + dp[index - ``2``],``                            ``arr2[index] + dp[index - ``2``]),``                        ``dp[index - ``1``]));``                ``++index;``            ``}` `            ``// Print maximum subset sum``            ``System.out.print(dp[length - ``1``]);``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``// Given arrays``        ``int` `arr1[] = { -``1``, -``2``, ``4``, -``4``, ``5` `};``        ``int` `arr2[] = { -``1``, -``2``, -``3``, ``4``, ``10` `};` `        ``// Length of the array``        ``int` `length = arr1.length;` `        ``maximumSubsetSum(arr1, arr2, length);``    ``}``}`

## Python3

 `# Python program of the above approach` `# Function to calculate maximum subset sum``def` `maximumSubsetSum(arr1, arr2, length) :` `    ``# Initialize array to store dp states``    ``dp ``=` `[``0``] ``*` `(length``+``1``)` `    ``# Base Cases``    ``if` `(length ``=``=` `1``) :     ``        ``print``(``max``(arr1[``0``], arr2[``0``]))``        ``return``    ``if` `(length ``=``=` `2``) :``        ``print``(``max``(``max``(arr1[``1``], arr2[``1``]), ``max``(arr1[``0``], arr2[``0``])))``        ``return` `    ``else`  `:` `        ``# Pre initializing for dp & dp``        ``dp[``0``] ``=` `max``(arr1[``0``], arr2[``0``])``        ``dp[``1``] ``=` `max``(``max``(arr1[``1``], arr2[``1``]), ``max``(arr1[``0``], arr2[``0``]))``        ``index ``=` `2``        ``while` `(index < length) :` `            ``# Calculating dp[index] based on``            ``# above formula``            ``dp[index] ``=` `max``(``max``(arr1[index], arr2[index]),``                ``max``(``max``(arr1[index] ``+` `dp[index ``-` `2``],``                        ``arr2[index] ``+` `dp[index ``-` `2``]),``                    ``dp[index ``-` `1``]))``            ``index ``+``=` `1``        ` `        ``# Print maximum subset sum``        ``print``(dp[length ``-` `1``])``    ` `# Driver Code` `# Given arrays``arr1 ``=` `[ ``-``1``, ``-``2``, ``4``, ``-``4``, ``5` `]``arr2 ``=` `[ ``-``1``, ``-``2``, ``-``3``, ``4``, ``10` `]` `# Length of the array``length ``=` `5``maximumSubsetSum(arr1, arr2, length)` `# This code is contributed by susmitakundugoaldanga.`

## C#

 `// C# program for the above approach``using` `System;``class` `GFG``{` `  ``// Function to calculate maximum subset sum``  ``static` `void` `maximumSubsetSum(``int``[] arr1,``                               ``int``[] arr2,``                               ``int` `length)``  ``{` `    ``// Initialize array to store dp states``    ``int``[] dp = ``new` `int``[length + 1];` `    ``// Base Cases``    ``if` `(length == 1) {``      ``Console.WriteLine(Math.Max(arr1, arr2));``      ``return``;``    ``}` `    ``if` `(length == 2)``    ``{``      ``Console.WriteLine(Math.Max(``        ``Math.Max(arr1, arr2),``        ``Math.Max(arr1, arr2)));``      ``return``;``    ``}``    ``else``    ``{` `      ``// Pre initializing for dp & dp``      ``dp = Math.Max(arr1, arr2);``      ``dp = Math.Max(Math.Max(arr1, arr2),``                       ``Math.Max(arr1, arr2));` `      ``int` `index = 2;``      ``while` `(index < length) {` `        ``// Calculating dp[index] based on``        ``// above formula``        ``dp[index] = Math.Max(Math.Max(arr1[index], arr2[index]),``                             ``Math.Max(Math.Max(arr1[index] +``                                               ``dp[index - 2],``                                               ``arr2[index] +``                                               ``dp[index - 2]),``                                      ``dp[index - 1]));``        ``++index;``      ``}` `      ``// Print maximum subset sum``      ``Console.WriteLine(dp[length - 1]);``    ``}``  ``}` `  ``// Driver Code``  ``static` `public` `void` `Main()``  ``{` `    ``// Given arrays``    ``int``[] arr1 = { -1, -2, 4, -4, 5 };``    ``int``[] arr2 = { -1, -2, -3, 4, 10 };` `    ``// Length of the array``    ``int` `length = arr1.Length;` `    ``maximumSubsetSum(arr1, arr2, length);``  ``}``}` `// This code is contributed by code_hunt.`

## Javascript

 ``

Output:

`14`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up