Maximize sum by shifting from one Array to other at most once

Last Updated : 01 Jun, 2023

Given two arrays X[] and Y[] of length N each. You can shift from X[] to Y[] at most once. The task is to output the maximum sum possible sum.

Examples:

Input: N = 4, X[] = {7, 5, 3, 4}, Y[] = {2, 3, 1, 3}
Output: 19
Explanation: It is optimal to not shift from X[] to Y[]. The total maximum possible sum will be 7 + 5 + 3 + 4 = 19.

Input: N = 2, X[] = {25, 5}, Y[] = {3, 30}
Output: 55
Explanation: It is optimal to shift after the first index.
Sum at first index= 25
After Shifted from X[] to Y[] after first index sum at second index = 25+Y[2] = 25 + 30 = 55.
It can be verified that sum more than 55 is not possible.

Approach: Implement the idea below to solve the problem

The problem can be solved by using prefix and suffix sum technique. For each index check the prefix sum and suffix sum. If we shift after index i, the sum (say X_i) will be prefix[i] + suffix[i+1].

The maximum value among all the X_i is the maximum possible sum by performing at most 1 shift.

Follow the steps mentioned below to implement the idea:

Initiate the suffix array of Y[].
Iterate from i=N-1 to 0 to generate the suffix array.
Traverse from i = 0 to N:
- Check if the sum of elements in X[] till i and the suffix sum of Y[] from i+1 is greater than the maximum possible sum.
- If it is greater, update the maximum possible.
Return the maximum possible after the iteration is over.

Code to implement the approach:

C++

// C++ code to implement the approach 
  
#include <iostream> 
using namespace std; 
  
// User defined find to maximum from two input arguments 
int max(int a, int b) { return a >= b ? a : b; } 
  
// Function for calculating maximum sum 
int maximiseSum(int n, int X[], int Y[]) 
{ 
  // Suffix sum array of Y[] 
  int suf[n]; 
  suf[n - 1] = Y[n - 1]; 
  
  // Variable to store sum of Y[] ans the maximum possible 
  // sum 
  int sum = 0, ans = 0; 
  
  // Loop for calculating suffix array of Y[] 
  for (int i = n - 2; i >= 0; i--) { 
    sum += Y[i]; 
    suf[i] += suf[i + 1]; 
  } 
  ans = sum; 
  sum = 0; 
  
  // Loop to find out the maximum possible sum 
  for (int i = 0; i < n - 1; i++) { 
    sum += X[i]; 
    ans = max(ans, sum + suf[i + 1]); 
  } 
  sum += X[n - 1]; 
  ans = max(ans, sum); 
  
  // Return the answer 
  return ans; 
} 
  
int main() 
{ 
  
  int N = 4; 
  int X[] = { 7, 5, 3, 4 }; 
  int Y[] = { 2, 3, 1, 3 }; 
  
  // Function call 
  cout << maximiseSum(N, X, Y); 
  return 0; 
} 
  
// This code is contributed by lokeshmvs21.

Java

// Java code to implement the approach 
  
import java.io.*; 
import java.lang.*; 
import java.util.*; 
  
class GFG { 
  
    // Driver Code 
    public static void main(String[] args) 
    { 
        int N = 4; 
        int[] X = { 7, 5, 3, 4 }; 
        int[] Y = { 2, 3, 1, 3 }; 
  
        // Function Call 
        System.out.println(maximiseSum(N, X, Y)); 
    } 
  
    // User defined find to maximum 
    // from two input arguments 
    static long max(long a, long b) 
    { 
        return a >= b ? a : b; 
    } 
  
    // Function for calculating maximum sum 
    static long maximiseSum(int n, int X[], int Y[]) 
    { 
        // Suffix sum array of Y[] 
        long[] suf = new long[n]; 
        suf[n - 1] = Y[n - 1]; 
  
        // Variable to store sum of Y[] 
        // ans the maximum possible sum 
        long sum = 0, ans = 0; 
  
        // Loop for calculating suffix array of Y[] 
        for (int i = n - 2; i >= 0; i--) { 
            sum += Y[i]; 
            suf[i] += suf[i + 1]; 
        } 
        ans = sum; 
        sum = 0; 
  
        // Loop to find out the maximum possible sum 
        for (int i = 0; i < n - 1; i++) { 
            sum += X[i]; 
            ans = max(ans, sum + suf[i + 1]); 
        } 
        sum += X[n - 1]; 
        ans = max(ans, sum); 
  
        // Return the answer 
        return ans; 
    } 
}

Python3

# Python code to implement the approach 
# Function for calculating maximum sum 
def maximiseSum(n, X, Y): 
    
    # Suffix sum array of Y[] 
    suf = [0]*n 
    suf[n - 1] = Y[n - 1] 
  
    # Variable to store sum of Y[] 
    # ans the maximum possible sum 
    sum = 0
    ans = 0
  
    # Loop for calculating suffix array of Y[] 
    for i in range(n-2, -1, -1): 
        sum += Y[i] 
        suf[i] += suf[i + 1] 
    ans = sum
    sum = 0
  
    # Loop to find out the maximum possible sum 
    for i in range(n-1): 
        sum += X[i] 
        ans = max(ans, sum + suf[i + 1]) 
    sum += X[n - 1] 
    ans = max(ans, sum) 
  
    # Return the answer 
    return ans 
  
N = 4
X = [7, 5, 3, 4] 
Y = [2, 3, 1, 3] 
print(maximiseSum(N, X, Y)) 
  
# This code is contributed by vikkycirus.

C#

// C# code to implement the approach 
  
using System; 
  
public class GFG { 
  
    // Function for calculating maximum sum 
    static long maximiseSum(int n, int[] X, int[] Y) 
    { 
        // Suffix sum array of Y[] 
        long[] suf = new long[n]; 
        suf[n - 1] = Y[n - 1]; 
  
        // Variable to store sum of Y[] 
        // ans the maximum possible sum 
        long sum = 0, ans = 0; 
  
        // Loop for calculating suffix array of Y[] 
        for (int i = n - 2; i >= 0; i--) { 
            sum += Y[i]; 
            suf[i] += suf[i + 1]; 
        } 
        ans = sum; 
        sum = 0; 
  
        // Loop to find out the maximum possible sum 
        for (int i = 0; i < n - 1; i++) { 
            sum += X[i]; 
            ans = max(ans, sum + suf[i + 1]); 
        } 
        sum += X[n - 1]; 
        ans = max(ans, sum); 
  
        // Return the answer 
        return ans; 
    } 
  
    // User defined find to maximum 
    // from two input arguments 
    static long max(long a, long b) 
    { 
        return a >= b ? a : b; 
    } 
  
    static public void Main() 
    { 
  
        // Code 
        int N = 4; 
        int[] X = { 7, 5, 3, 4 }; 
        int[] Y = { 2, 3, 1, 3 }; 
  
        // Function Call 
        Console.WriteLine(maximiseSum(N, X, Y)); 
    } 
} 
  
// This code is contributed by lokeshmvs21.

Javascript

// JavaScript code to implement the approach 
 
// User defined find to maximum 
// from two input arguments 
function max(a, b){ 
    return a >= b ? a : b; 
} 
  
// Function for calculating maximum sum 
function maximizeSum(n, X, Y){ 
    // Suffix sum array of Y[] 
    let suf = new Array(); 
    suf[n-1] = Y[n-1]; 
      
    // Variable to store sum of Y[] 
    // ans the maximum possible sum 
    let sum = 0, ans = 0; 
      
    // Loop for calculating suffix array of Y[] 
    for (let i = n - 2; i >= 0; i--) { 
        sum += Y[i]; 
        suf[i] += suf[i + 1]; 
    } 
    ans = sum; 
    sum = 0; 
 
    // Loop to find out the maximum possible sum 
    for (let i = 0; i < n - 1; i++) { 
        sum += X[i]; 
        ans = max(ans, sum + suf[i + 1]); 
    } 
    sum += X[n - 1]; 
    ans = max(ans, sum); 
 
    // Return the answer 
    return ans; 
} 
 
let N = 4; 
let X = [ 7, 5, 3, 4 ]; 
let Y = [ 2, 3, 1, 3 ]; 
  
// Function call 
console.log(maximizeSum(N, X, Y)); 
  
// This code is contributed by lokesh.

Output

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

Related Articles:

Introduction to Arrays – Data Structures and Algorithms Tutorials

Maximize array sum by replacing at most L elements to R for Q queries

pradeep6036ymca

Improve

Article Tags :

Practice Tags :

Maximize sum by shifting from one Array to other at most once

C++

Java

Python3

C#

Javascript

Similar Reads

Thank You!

What kind of Experience do you want to share?