Skip to content
Related Articles

Related Articles

Maximize sum that can be obtained from two given arrays based on given conditions

View Discussion
Improve Article
Save Article
  • Difficulty Level : Hard
  • Last Updated : 13 Sep, 2021
View Discussion
Improve Article
Save Article

Given two arrays A[] and B[] each of size N, the task is to find the maximum sum that can be obtained based on the following conditions:

  • Both A[i] and B[i] cannot be included in the sum ( 0 ≤ i ≤ N – 1 ).
  • If B[i] is added to the sum, then B[i – 1] and A[i – 1] cannot be included in the sum ( 0 ≤ i ≤ N – 1 ).

Examples:

Input: A[] = {10, 20, 5}, B[] = {5, 5, 45}
Output: 55
Explanation: The optimal way to maximize the sum is by including A[0] (= 10) and B[2] (= 45) in the sum. Therefore, sum = 10 + 45 = 55.

Input: A[] = {10, 1, 10, 10}, B[] = {5, 50, 1, 5}
Output: 70

Approach: This problem has Optimal substructure and Overlapping subproblems. Therefore, Dynamic Programming can be used to solve the problem. 
Follow the steps below to solve the problem:

  • Initialize a array, say dp[n][2], where dp[i][0] stores the maximum sum if element A[i] is taken into consideration and dp[i][1] stores the maximum sum if B[i] is taken into consideration.
  • Iterate in the range [0, N – 1] using a variable, say i, and perform the following steps:
    • If i is equal to 0, then modify the value of dp[i][0] as A[i] and dp[i][1] as B[i].
    • Otherwise, perform the following operations:
      • Modify the value of dp[i][0] as max(dp[i – 1][0], dp[i – 1][1]) + A[i].
      • Modify the value of dp[i][1] as max(dp[i – 1], max(dp[i – 1][0], max(dp[i – 2][0], dp[i – 2][1]) + B[i])).
  • After completing the above steps, print the max(dp[N-1][0], dp[N-1][1]) as the answer.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the maximum sum
// that can be obtained from two given
// based on the following conditions
int MaximumSum(int a[], int b[], int n)
{
    // Stores the maximum
    // sum from 0 to i
    int dp[n][2];
 
    // Initialize the value of
    // dp[0][0] and dp[0][1]
    dp[0][0] = a[0];
    dp[0][1] = b[0];
 
    // Traverse the array A[] and B[]
    for (int i = 1; i < n; i++) {
        // If A[i] is considered
        dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]) + a[i];
 
        // If B[i] is not considered
        dp[i][1] = max(dp[i - 1][0], dp[i - 1][1]);
 
        // If B[i] is considered
        if (i - 2 >= 0) {
            dp[i][1] = max(dp[i][1],
                           max(dp[i - 2][0],
                               dp[i - 2][1])
                               + b[i]);
        }
        else {
            // If i = 1, then consider the
            // value of  dp[i][1] as b[i]
            dp[i][1] = max(dp[i][1], b[i]);
        }
    }
 
    // Return maximum Sum
    return max(dp[n - 1][0], dp[n - 1][1]);
}
 
// Driver Code
int main()
{
    // Given Input
    int A[] = { 10, 1, 10, 10 };
    int B[] = { 5, 50, 1, 5 };
    int N = sizeof(A) / sizeof(A[0]);
 
    // Function Call
    cout << MaximumSum(A, B, N);
    return 0;
}

Java




// Java program for the above approach
 
class GFG {
    // Function to find the maximum sum
    // that can be obtained from two given
    // based on the following conditions
    public static int MaximumSum(int a[], int b[], int n) {
        // Stores the maximum
        // sum from 0 to i
        int[][] dp = new int[n][2];
 
        // Initialize the value of
        // dp[0][0] and dp[0][1]
        dp[0][0] = a[0];
        dp[0][1] = b[0];
 
        // Traverse the array A[] and B[]
        for (int i = 1; i < n; i++) {
            // If A[i] is considered
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1]) + a[i];
 
            // If B[i] is not considered
            dp[i][1] = Math.max(dp[i - 1][0], dp[i - 1][1]);
 
            // If B[i] is considered
            if (i - 2 >= 0) {
                dp[i][1] = Math.max(dp[i][1], Math.max(dp[i - 2][0], dp[i - 2][1]) + b[i]);
            } else
            {
               
                // If i = 1, then consider the
                // value of dp[i][1] as b[i]
                dp[i][1] = Math.max(dp[i][1], b[i]);
            }
        }
 
        // Return maximum Sum
        return Math.max(dp[n - 1][0], dp[n - 1][1]);
    }
 
    // Driver Code
    public static void main(String args[]) {
        // Given Input
        int A[] = { 10, 1, 10, 10 };
        int B[] = { 5, 50, 1, 5 };
        int N = A.length;
 
        // Function Call
        System.out.println(MaximumSum(A, B, N));
    }
}
 
// This  code is contributed by _saurabh_jaiswal.

Python3




# Python3 program for the above approach
 
# Function to find the maximum sum
# that can be obtained from two given
# arrays based on the following conditions
def MaximumSum(a, b, n):
   
    # Stores the maximum
    # sum from 0 to i
    dp = [[-1 for j in range(2)]
              for i in range(n)]
     
    # Initialize the value of
    # dp[0][0] and dp[0][1]
    dp[0][0] = a[0]
    dp[0][1] = b[0]
     
    # Traverse the array A[] and B[]
    for i in range(1, n):
       
        # If A[i] is considered
        dp[i][0] = max(dp[i - 1][0],
                       dp[i - 1][1]) + a[i]
         
        # If B[i] is not considered
        dp[i][1] = max(dp[i - 1][0],
                       dp[i - 1][1])
         
        # If B[i] is considered
        if (i - 2 >= 0):
            dp[i][1] = max(dp[i][1], max(dp[i - 2][0],
                                         dp[i - 2][1]) + b[i])
        else:
             
            # If i = 1, then consider the
            # value of  dp[i][1] as b[i]
            dp[i][1] = max(dp[i][1], b[i])
 
    # Return maximum sum
    return max(dp[n - 1][0], dp[n - 1][1])
 
# Driver code
if __name__ == '__main__':
     
    # Given input
    A = [ 10, 1, 10, 10 ]
    B = [ 5, 50, 1, 5 ]
    N = len(A)
     
    # Function call
    print(MaximumSum(A, B, N))
     
# This code is contributed by MuskanKalra1

C#




// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to find the maximum sum
// that can be obtained from two given
// based on the following conditions
static int MaximumSum(int []a, int []b, int n)
{
   
    // Stores the maximum
    // sum from 0 to i
    int [,]dp = new int[n,2];
 
    // Initialize the value of
    // dp[0][0] and dp[0][1]
    dp[0,0] = a[0];
    dp[0,1] = b[0];
 
    // Traverse the array A[] and B[]
    for (int i = 1; i < n; i++)
    {
       
        // If A[i] is considered
        dp[i,0] = Math.Max(dp[i - 1,0], dp[i - 1,1]) + a[i];
 
        // If B[i] is not considered
        dp[i,1] = Math.Max(dp[i - 1,0], dp[i - 1,1]);
 
        // If B[i] is considered
        if (i - 2 >= 0) {
            dp[i,1] = Math.Max(dp[i,1],
                           Math.Max(dp[i - 2,0],
                               dp[i - 2,1])
                               + b[i]);
        }
        else
        {
           
            // If i = 1, then consider the
            // value of  dp[i][1] as b[i]
            dp[i,1] = Math.Max(dp[i,1], b[i]);
        }
    }
 
    // Return maximum Sum
    return Math.Max(dp[n - 1,0], dp[n - 1,1]);
}
 
// Driver Code
public static void Main()
{
    // Given Input
    int []A = { 10, 1, 10, 10 };
    int []B = { 5, 50, 1, 5 };
    int N = A.Length;
 
    // Function Call
    Console.Write(MaximumSum(A, B, N));
}
}
 
// This code is contributed by ipg2016107.

Javascript




<script>
 
// Javascript program for the above approach
 
// Function to find the maximum sum
// that can be obtained from two given
// based on the following conditions
function MaximumSum(a, b, n)
{
     
    // Stores the maximum
    // sum from 0 to i
    let dp = new Array(n).fill(0).map(
       () => new Array(2));
 
    // Initialize the value of
    // dp[0][0] and dp[0][1]
    dp[0][0] = a[0];
    dp[0][1] = b[0];
 
    // Traverse the array A[] and B[]
    for(let i = 1; i < n; i++)
    {
         
        // If A[i] is considered
        dp[i][0] = Math.max(dp[i - 1][0],
                            dp[i - 1][1]) + a[i];
 
        // If B[i] is not considered
        dp[i][1] = Math.max(dp[i - 1][0],
                            dp[i - 1][1]);
 
        // If B[i] is considered
        if (i - 2 >= 0)
        {
            dp[i][1] = Math.max(dp[i][1],
                Math.max(dp[i - 2][0],
                          dp[i - 2][1]) + b[i]);
        }
        else
        {
             
            // If i = 1, then consider the
            // value of  dp[i][1] as b[i]
            dp[i][1] = Math.max(dp[i][1], b[i]);
        }
    }
 
    // Return maximum Sum
    return Math.max(dp[n - 1][0], dp[n - 1][1]);
}
 
// Driver Code
 
// Given Input
let A = [ 10, 1, 10, 10 ];
let B = [ 5, 50, 1, 5 ];
let N = A.length;
 
// Function Call
document.write(MaximumSum(A, B, N));
 
// This code is contributed by gfgking
 
</script>

Output: 

70

 

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


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!