Maximize sum of subsets from two arrays having no consecutive values
Last Updated :
16 Oct, 2023
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[1] = max(arr1[1], arr2[1]).
- dp[2] = max(max(arr1[1], arr2[1]), max(arr1[2], arr2[2])).
- 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++
#include <bits/stdc++.h>
using namespace std;
void maximumSubsetSum( int arr1[], int arr2[], int length)
{
int dp[length+1];
if (length == 1)
{
cout << (max(arr1[0], arr2[0]));
return ;
}
if (length == 2)
{
cout << (max(max(arr1[1], arr2[1]), max(arr1[0], arr2[0])));
return ;
}
else
{
dp[0] = max(arr1[0], arr2[0]);
dp[1] = max(max(arr1[1], arr2[1]), max(arr1[0], arr2[0]));
int index = 2;
while (index < length)
{
dp[index] = max(max(arr1[index], arr2[index]),
max(max(arr1[index] + dp[index - 2],
arr2[index] + dp[index - 2]),
dp[index - 1]));
++index;
}
cout<<(dp[length - 1]);
}
}
int main()
{
int arr1[] = { -1, -2, 4, -4, 5 };
int arr2[] = { -1, -2, -3, 4, 10 };
int length = 5;
maximumSubsetSum(arr1, arr2, length);
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG {
static void maximumSubsetSum( int arr1[],
int arr2[],
int length)
{
int dp[] = new int [length + 1 ];
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 {
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) {
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;
}
System.out.print(dp[length - 1 ]);
}
}
public static void main(String[] args)
{
int arr1[] = { - 1 , - 2 , 4 , - 4 , 5 };
int arr2[] = { - 1 , - 2 , - 3 , 4 , 10 };
int length = arr1.length;
maximumSubsetSum(arr1, arr2, length);
}
}
|
Python3
def maximumSubsetSum(arr1, arr2, length) :
dp = [ 0 ] * (length + 1 )
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 :
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) :
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 (dp[length - 1 ])
arr1 = [ - 1 , - 2 , 4 , - 4 , 5 ]
arr2 = [ - 1 , - 2 , - 3 , 4 , 10 ]
length = 5
maximumSubsetSum(arr1, arr2, length)
|
C#
using System;
class GFG
{
static void maximumSubsetSum( int [] arr1,
int [] arr2,
int length)
{
int [] dp = new int [length + 1];
if (length == 1) {
Console.WriteLine(Math.Max(arr1[0], arr2[0]));
return ;
}
if (length == 2)
{
Console.WriteLine(Math.Max(
Math.Max(arr1[1], arr2[1]),
Math.Max(arr1[0], arr2[0])));
return ;
}
else
{
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) {
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;
}
Console.WriteLine(dp[length - 1]);
}
}
static public void Main()
{
int [] arr1 = { -1, -2, 4, -4, 5 };
int [] arr2 = { -1, -2, -3, 4, 10 };
int length = arr1.Length;
maximumSubsetSum(arr1, arr2, length);
}
}
|
Javascript
<script>
function maximumSubsetSum(arr1, arr2,length)
{
let dp = new Array(length).fill(0);;
if (length == 1) {
document.write(
Math.max(arr1[0], arr2[0]));
return ;
}
if (length == 2) {
document.write(
Math.max(
Math.max(arr1[1], arr2[1]),
Math.max(arr1[0], arr2[0])));
return ;
}
else {
dp[0] = Math.max(arr1[0], arr2[0]);
dp[1] = Math.max(
Math.max(arr1[1], arr2[1]),
Math.max(arr1[0], arr2[0]));
let index = 2;
while (index < length) {
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;
}
document.write(dp[length - 1]);
}
}
let arr1 = [ -1, -2, 4, -4, 5 ];
let arr2 = [ -1, -2, -3, 4, 10 ];
let length = arr1.length;
maximumSubsetSum(arr1, arr2, length);
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(N)
Efficient approach : Space optimization O(1)
In previous approach we the current value dp[i] is only depend upon the previous 2 values i.e. dp[i-1] and dp[i-2]. So to optimize the space we can keep track of previous and current values by the help of three variables prev1, prev2 and curr which will reduce the space complexity from O(x) to O(1).
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
void maximumSubsetSum( int arr1[], int arr2[], int length)
{
int dp0 = max(arr1[0], arr2[0]);
int dp1 = max(max(arr1[1], arr2[1]), max(arr1[0], arr2[0]));
int dpi = dp1, dpim2 = dp0;
if (length == 1)
{
cout << dp0;
return ;
}
if (length == 2)
{
cout << dp1;
return ;
}
else
{
int index = 2;
while (index < length)
{
dpi = max(max(arr1[index], arr2[index]),
max(max(arr1[index] + dpim2,
arr2[index] + dpim2),
dp1));
dpim2 = dp1;
dp1 = dpi;
++index;
}
cout<<(dpi);
}
}
int main()
{
int arr1[] = { -1, -2, 4, -4, 5 };
int arr2[] = { -1, -2, -3, 4, 10 };
int length = 5;
maximumSubsetSum(arr1, arr2, length);
return 0;
}
|
Java
public class GFG {
static void maximumSubsetSum( int [] arr1, int [] arr2, int length) {
int dp0 = Math.max(arr1[ 0 ], arr2[ 0 ]);
int dp1 = Math.max(Math.max(arr1[ 1 ], arr2[ 1 ]), Math.max(arr1[ 0 ], arr2[ 0 ]));
int dpi = dp1, dpim2 = dp0;
if (length == 1 ) {
System.out.println(dp0);
return ;
}
if (length == 2 ) {
System.out.println(dp1);
return ;
} else {
int index = 2 ;
while (index < length) {
dpi = Math.max(Math.max(arr1[index], arr2[index]),
Math.max(Math.max(arr1[index] + dpim2,
arr2[index] + dpim2),
dp1));
dpim2 = dp1;
dp1 = dpi;
++index;
}
System.out.println(dpi);
}
}
public static void main(String[] args) {
int [] arr1 = { - 1 , - 2 , 4 , - 4 , 5 };
int [] arr2 = { - 1 , - 2 , - 3 , 4 , 10 };
int length = 5 ;
maximumSubsetSum(arr1, arr2, length);
}
}
|
Python3
def maximumSubsetSum(arr1, arr2, length):
dp0 = max (arr1[ 0 ], arr2[ 0 ])
dp1 = max ( max (arr1[ 1 ], arr2[ 1 ]), max (arr1[ 0 ], arr2[ 0 ]))
dpi, dpim2 = dp1, dp0
if length = = 1 :
print (dp0)
return
if length = = 2 :
print (dp1)
return
else :
index = 2
while index < length:
dpi = max (
max (arr1[index], arr2[index]),
max (
max (arr1[index] + dpim2, arr2[index] + dpim2),
dp1
)
)
dpim2 = dp1
dp1 = dpi
index + = 1
print (dpi)
if __name__ = = "__main__" :
arr1 = [ - 1 , - 2 , 4 , - 4 , 5 ]
arr2 = [ - 1 , - 2 , - 3 , 4 , 10 ]
length = 5
maximumSubsetSum(arr1, arr2, length)
|
C#
using System;
class Program
{
static void MaximumSubsetSum( int [] arr1, int [] arr2, int length)
{
int dp0 = Math.Max(arr1[0], arr2[0]);
int dp1 = Math.Max(Math.Max(arr1[1], arr2[1]), Math.Max(arr1[0], arr2[0]));
int dpi = dp1, dpim2 = dp0;
if (length == 1)
{
Console.Write(dp0);
return ;
}
if (length == 2)
{
Console.Write(dp1);
return ;
}
else
{
int index = 2;
while (index < length)
{
dpi = Math.Max(Math.Max(arr1[index], arr2[index]),
Math.Max(Math.Max(arr1[index] + dpim2,
arr2[index] + dpim2),
dp1));
dpim2 = dp1;
dp1 = dpi;
++index;
}
Console.Write(dpi);
}
}
static void Main( string [] args)
{
int [] arr1 = { -1, -2, 4, -4, 5 };
int [] arr2 = { -1, -2, -3, 4, 10 };
int length = 5;
MaximumSubsetSum(arr1, arr2, length);
}
}
|
Javascript
function maximumSubsetSum(arr1, arr2, length) {
let dp0 = Math.max(arr1[0], arr2[0]);
let dp1 = Math.max(Math.max(arr1[1], arr2[1]), Math.max(arr1[0], arr2[0]));
let dpi = dp1;
let dpim2 = dp0;
if (length === 1) {
console.log(dp0);
return ;
}
if (length === 2) {
console.log(dp1);
return ;
} else {
let index = 2;
while (index < length) {
dpi = Math.max(
Math.max(arr1[index], arr2[index]),
Math.max(
Math.max(arr1[index] + dpim2, arr2[index] + dpim2),
dp1
)
);
dpim2 = dp1;
dp1 = dpi;
index++;
}
console.log(dpi);
}
}
const arr1 = [-1, -2, 4, -4, 5];
const arr2 = [-1, -2, -3, 4, 10];
const length = 5;
maximumSubsetSum(arr1, arr2, length);
|
Time Complexity: O(N)
Auxiliary Space: O(1)
Share your thoughts in the comments
Please Login to comment...