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]).
-
Base Cases:
- Finally, print dp[N] as the required answer.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> 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[0], arr2[0]));
return ;
}
if (length == 2)
{
cout << (max(max(arr1[1], arr2[1]), max(arr1[0], arr2[0])));
return ;
}
else
{
// Pre initializing for dp[0] & dp[1]
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)
{
// 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 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[0] & dp[1]
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);
}
} |
# 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[0] & dp[1]
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# 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[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
{
// Pre initializing for dp[0] & dp[1]
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
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. |
<script> // javascript program of the above approach // Function to calculate maximum subset sum
function maximumSubsetSum(arr1, arr2,length)
{
// Initialize array to store dp states
let dp = new Array(length).fill(0);;
// Base Cases
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 {
// Pre initializing for dp[0] & dp[1]
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) {
// 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
document.write(dp[length - 1]);
}
}
// Driver Code
// Given arrays
let arr1 = [ -1, -2, 4, -4, 5 ];
let arr2 = [ -1, -2, -3, 4, 10 ];
// Length of the array
let length = arr1.length;
maximumSubsetSum(arr1, arr2, length);
</script> |
14
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++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to calculate maximum subset sum void maximumSubsetSum( int arr1[], int arr2[], int length)
{ // Initialize variables to store dp states
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;
// Base Cases
if (length == 1)
{
cout << dp0;
return ;
}
if (length == 2)
{
cout << dp1;
return ;
}
else
{
int index = 2;
while (index < length)
{
// Calculating dp[index] based on above formula
dpi = max(max(arr1[index], arr2[index]),
max(max(arr1[index] + dpim2,
arr2[index] + dpim2),
dp1));
dpim2 = dp1;
dp1 = dpi;
++index;
}
// Print maximum subset sum
cout<<(dpi);
}
} // 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;
} |
public class GFG {
// Function to calculate maximum subset sum
static void maximumSubsetSum( int [] arr1, int [] arr2, int length) {
// Initialize variables to store dp states
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;
// Base Cases
if (length == 1 ) {
System.out.println(dp0);
return ;
}
if (length == 2 ) {
System.out.println(dp1);
return ;
} else {
int index = 2 ;
while (index < length) {
// Calculating dp[index] based on the formula
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;
}
// Print maximum subset sum
System.out.println(dpi);
}
}
// 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 = 5 ;
maximumSubsetSum(arr1, arr2, length);
}
} |
def maximumSubsetSum(arr1, arr2, length):
# Initialize variables to store dp states
dp0 = max (arr1[ 0 ], arr2[ 0 ])
dp1 = max ( max (arr1[ 1 ], arr2[ 1 ]), max (arr1[ 0 ], arr2[ 0 ]))
dpi, dpim2 = dp1, dp0
# Base Cases
if length = = 1 :
print (dp0)
return
if length = = 2 :
print (dp1)
return
else :
index = 2
while index < length:
# Calculating dpi based on the given formula
dpi = max (
max (arr1[index], arr2[index]),
max (
max (arr1[index] + dpim2, arr2[index] + dpim2),
dp1
)
)
dpim2 = dp1
dp1 = dpi
index + = 1
# Print maximum subset sum
print (dpi)
# Driver Code if __name__ = = "__main__" :
# Given arrays
arr1 = [ - 1 , - 2 , 4 , - 4 , 5 ]
arr2 = [ - 1 , - 2 , - 3 , 4 , 10 ]
# Length of the array
length = 5
maximumSubsetSum(arr1, arr2, length)
|
using System;
class Program
{ static void MaximumSubsetSum( int [] arr1, int [] arr2, int length)
{
// Initialize variables to store dp states
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;
// Base Cases
if (length == 1)
{
Console.Write(dp0);
return ;
}
if (length == 2)
{
Console.Write(dp1);
return ;
}
else
{
int index = 2;
while (index < length)
{
// Calculating dp[index] based on above formula
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);
}
} |
function maximumSubsetSum(arr1, arr2, length) {
// Initialize variables to store dp states
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;
// Base Cases
if (length === 1) {
console.log(dp0); // Print the maximum subset sum
return ;
}
if (length === 2) {
console.log(dp1); // Print the maximum subset sum
return ;
} else {
let index = 2;
while (index < length) {
// Calculate dpi based on the maximum of different cases
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); // Print the maximum subset sum
}
} const arr1 = [-1, -2, 4, -4, 5]; const arr2 = [-1, -2, -3, 4, 10]; const length = 5; maximumSubsetSum(arr1, arr2, length); |
14
Time Complexity: O(N)
Auxiliary Space: O(1)