Skip to content
Related Articles

Related Articles

Improve Article

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

  • Difficulty Level : Hard
  • Last Updated : 13 Sep, 2021

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)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :