Maximize Array sum by adding multiple of another Array element in given ranges

Last Updated : 21 Feb, 2023

Given two arrays X[] and Y[] of length N along with Q queries each of type [L, R] that denotes the subarray of X[] from L to R. The task is to find the maximum sum that can be obtained by applying the following operation for each query:

Choose an element from Y[].
Add multiples with alternate +ve and -ve signs to the elements of the subarray. i.e., if the chosen element is 4, then modify the subarray as {X_L+ 4, X_L+1 - 8, . . . (till R^th) index}
Delete the element chosen from Y.

Note: 1-based indexing is used here.

Examples:

Input: N = 4, X[] = {1, 2, 3, 4}, Y[] = {2, 3, 5, 6}, K = 1, query = {{3, 3}}
Output: 16
Explanation:
Number of queries = 1
Sub-array from start to end index of X[]: {3}
Chose 6 from Y[] and then add alternative series of multiple of 6 = {3 + 6} = {9}. Rest of the elements except the sub-array will remain the same, Therefore, new X[] is: {1, 2, 9, 4}. The maximum sum that can obtain from
X[] = 1+ 2+ 9+ 4 = 16

Input: N = 5, X[] = {5, 7, 2, 1, 8}, Y[] = {1, 2, 3, 4, 5}, K = 2, queries = {{1, 4}, {1, 5}}
Output: 36
Explanation:
start = 1, end = 4
The subarray = {7, 2, 1, 8}
Lets chose 1 from Y[] and add series of multiple of 1 in subarray = {7 + 1, 2 - 2, 1 + 3, 8 - 4} = {8, 0, 4, 4}.
X[]: {5, 8, 0, 4, 4}
Now, start = 1, end = 5
The subarray = {5, 8, 0, 4, 4}
lets chose 5 from Y[] and add series of multiple of 5 in subarray = {5 + 5, 8 - 10, 0 + 15, 4 - 20, 4 + 25} = {10, -2, 15, -16, 29}. Now updated X[] will be: {10, -2, 15, -16, 29}.
Overall sum of X[] is : (10 - 2 + 15 - 16 + 29) = 36. It can be verified that this sum is maximum possible.

Intuition: The intuition behind the approach is provided below

Let us take an example of series of multiple of an integer let say K. Then the series will be as the picture below:

Series of multiple of K

It can be seen clearly that if subarray of series is of odd length then it will contribute a positive sum in the overall sum, While series of even length will contribute negative sum to the total sum.

So the optimal idea is to add the multiples of the biggest value to the largest odd length subarray and the multiples of the smallest value to the largest even length subarray.

Naive Approach:

In this method, we will do the same as mentioned in the problem statement. We will traverse on each sub-array by the given start and end indices in each query and add series of multiple of the optimal element at that current state so that our sum is maximized.

Follow the steps mentioned below to implement the idea:

Make ArrayList of Pairs<Start, End> DataType and initialize it with Pairs of start and end indices of given sub-arrays in query.
Sort Queries in ArrayList according to the length of sub-arrays, Formally arrange Pairs in descending order of length.
Sort Y[]. It will be convenient to get minimum and maximum elements and delete them after use.
Run a loop number of times queries are asked then do the following steps:
- Calculate the length of the current subarray. If the length is even take a minimum element of Y[] else take the maximum.
- Traverse on sub-array and add the series of Multiple into it.
- Delete the used element of Y[].
Calculate the overall sum of elements present in the X[] by traversing array X[]
Print the sum as the required answer.

Below is the implementation of the above approach.

C++

// C++ code to implement the approach  #include<bits/stdc++.h> using namespace std;  // Function to get maximum value after K // queries void maximumSum(int X[], int Y[], int N, int K,vector<int> &list) {   // Variable for holding maximum sum that can be   // obtained   long sum = 0;    // Loop for calculating initial sum of X[]   for (int i = 0; i < N; i++) {     sum += X[i];   }    // Start pointer for Y[]   int s = 0;    // End pointer of Y[]   int e = N - 1;    // Loop for Executing Queries in descending order of   // length   for (int i = list.size() - 1; i >= 0; i--) {      // Variable to hold length of subarray     int length = list[i];      // element needed to be add optimally     int element = length % 2 == 0 ? Y[s] : Y[e];      // Increasing or decreasing start and end     // pointers After using element at that pointers     if (length % 2 == 0) {       s++;     }     else {       e--;     }      // Condition when length is even     if (length % 2 == 0) {        // Subtracting from the       // overall sum       sum = sum - ((length / 2) * element);     }     else {        // Adding increment in       // overall sum       sum = sum + (((length + 1) / 2) * element);     }   }   // Printing value of sum   cout<<sum; }  // Driver code int main() {   int N = 3;   int X[] = { 1, 2, 3 };   int Y[] = { 4, 3, 1 };   int K = 2;    // Start[] and end[] of K length holds   // starting and ending indices   // of sub-array   int start[] = { 1, 1 };   int end[] = { 1, 3 };    // ArrayList of length of sub-arrays in each query   vector<int> list;   for (int i = 0; i < K; i++) {     list.push_back((end[i] - start[i]) + 1);   }    // Sorting ArrayList   sort(list.begin(),list.end());    // Sorting Y[] using in-built sort function   sort(Y,Y+N);    // Function call for getting maximum Sum   maximumSum(X, Y, N, K, list);    return 0; }  // This code is contributed by Pushpesh Raj.

Java

// Java code to implement the approach  import java.io.*; import java.lang.*; import java.util.*;  // User defined Pair class class Pair {      // Two variables to store start and end indices     // respectively     int x, y;      // Constructor of Pair class     Pair(int x, int y)     {         this.x = x;         this.y = y;     }      // Function for returning length of a Pair(Formally     // length of sub-array) According to 1 based indexing     int length() { return (this.y - this.x) + 1; } } class GFG {      // Function to get maximum Sum after     // K queries     static void maximumSum(int X[], int Y[], int N,                            ArrayList<Pair> list, int K)     {          // Variable to calculate overall sum         long sum = 0;          // Maintaining two pointers to get         // maximum and minimum element from         // Y[]         int s = 0;         int e = Y.length - 1;          // Loop for Traversing on Pairs         for (int i = 0; i < list.size(); i++) {              // Variable S holds start index             // of query             int S = list.get(i).x;              // Variable E holds start index             // of query             int E = list.get(i).y;              // length variable stores length             // of sub-array using S and             // E(1 based indexing)             int length = list.get(i).length();              // If length is even the minimum             // element will be store in             // "element" variable else Maximum             // element will be store in it             int element = length % 2 == 0 ? Y[s] : Y[e];              // Removing chose element from             // Y[]             if (length % 2 == 0) {                  s++;             }             else {                 e--;             }              // Counter initialized to 1             int counter = 1;              // Loop for traversing on given             // sub-array as queries             // 1 based indexing, Therefore, S-1 to <E             for (int j = S - 1; j < E; j++) {                  // The below if-else                 // conditions  is adding AP                 // of +ve and -ve elements                 if (counter % 2 != 0) {                      X[j] = X[j] + (counter * element);                 }                 else {                     X[j] = X[j] - (counter * element);                 }                  // Incrementing counter                 counter++;             }         }          // Loop for traversing on X[] after         // K Queries so that we can obtain         // its sum         for (int i = 0; i < N; i++) {              // Adding element of X[] into             // sum variable             sum += X[i];         }          // Printing value of sum         System.out.println(sum);     }      // Driver code     public static void main(String[] args)     {          int N = 3;         int[] X = { 1, 2, 3 };         int[] Y = { 1, 3, 4 };         int K = 2;          // Start[] and end[] of K length         // holds starting and ending indices         // of sub-array         int[] start = { 1, 1 };         int[] end = { 3, 1 };          // ArrayList of Pair type to store given start and         // end indices as Pair<start, end>         ArrayList<Pair> list = new ArrayList<>();          // Loop for initializing list as Pairs         for (int i = 0; i < K; i++) {             list.add(new Pair(start[i], end[i]));         }          // Sorting list in descending order using user         // defined Selection-sort function         SortList(list);          // sorting Y[] using in-built sort function         Arrays.sort(Y);          // function call for obtaining maximum sum         maximumSum(X, Y, N, list, K);     }      // User defined Function for sorting list(Selection Sort     // is used)     static void SortList(ArrayList<Pair> list)     {         for (int i = 0; i < list.size() - 1; i++) {             int max = i;             for (int j = i + 1; j < list.size(); j++) {                 if (list.get(max).length()                     < list.get(j).length()) {                     max = j;                 }             }             Pair temp                 = new Pair(list.get(i).x, list.get(i).y);             list.get(i).x = list.get(max).x;             list.get(i).y = list.get(max).y;             list.get(max).x = temp.x;             list.get(max).y = temp.y;         }     } }

Python3

# Python implementation from typing import List  def maximumSum(X: List[int], Y: List[int], N: int, K: int, list: List[int]) -> None:     # Variable for holding maximum sum that can be obtained     sum = 0      # Loop for calculating initial sum of X[]     for i in range(N):         sum += X[i]      # Start pointer for Y[]     s = 0      # End pointer of Y[]     e = N - 1      # Loop for Executing Queries in descending order of length     for i in range(len(list) - 1, -1, -1):         # Variable to hold length of subarray         length = list[i]          # element needed to be add optimally         element = Y[s] if length % 2 == 0 else Y[e]          # Increasing or decreasing start and end pointers After using element at that pointers         if length % 2 == 0:             s += 1         else:             e -= 1          # Condition when length is even         if length % 2 == 0:             # Subtracting from the overall sum             sum = sum - ((length // 2) * element)         else:             # Adding increment in overall sum             sum = sum + (((length + 1) // 2) * element)      # Printing value of sum     print(sum)  # Driver code   def main():     N = 3     X = [1, 2, 3]     Y = [4, 3, 1]     K = 2      # Start[] and end[] of K length holds starting and ending indices of sub-array     start = [1, 1]     end = [1, 3]      # ArrayList of length of sub-arrays in each query     arr_list = [(end[i] - start[i]) + 1 for i in range(K)]      # Sorting ArrayList     arr_list.sort()      # Sorting Y[] using in-built sort function     Y.sort()      # Function call for getting maximum Sum     maximumSum(X, Y, N, K, arr_list)  if __name__ == '__main__':     main()  # This code is contributed by ksam24000

JavaScript

// JavaScript code to implement the approach  // Function to get maximum value after K // queries function maximumSum(X, Y, N, K, list) {   // Variable for holding maximum sum that can be   // obtained    sum = 0;    // Loop for calculating initial sum of X[]   for (let i = 0; i < N; i++) {     sum += X[i];   }    // Start pointer for Y[]   let s = 0;    // End pointer of Y[]   let e = N - 1;    // Loop for Executing Queries in descending order of   // length   for (let i = list.length - 1; i >= 0; i--) {      // Variable to hold length of subarray     let length = list[i];      // element needed to be add optimally     let element = length % 2 == 0 ? Y[s] : Y[e];      // Increasing or decreasing start and end     // poleters After using element at that poleters     if (length % 2 == 0) {       s++;     }     else {       e--;     }      // Condition when length is even     if (length % 2 == 0) {        // Subtracting from the       // overall sum       sum = sum - ((length / 2) * element);     }     else {        // Adding increment in       // overall sum       sum = sum + (((length + 1) / 2) * element);     }   }   // Printing value of sum   document.write(sum); }  // Driver code    let N = 3;   let X = [ 1, 2, 3 ];   let Y = [4, 3, 1 ];   let K = 2;    // Start[] and end[] of K length holds   // starting and ending indices   // of sub-array   let start = [1, 1 ];   let end = [1, 3 ];    // ArrayList of length of sub-arrays in each query   let list=[];   for (let i = 0; i < K; i++) {     list.push((end[i] - start[i]) + 1);   }    // Sorting ArrayList   list.sort();    // Sorting Y[] using in-built sort function   Y.sort();      // Function call for getting maximum Sum   maximumSum(X, Y, N, K, list);      // This code is contributed by poojaagarwal2.

// C# implementation of the above approach using System; using System.Collections.Generic;  class GFG {          // Function to get maximum value after K     // queries     static void maximumSum(int[] X, int[] Y, int N, int K,List<int> list)     {              // Variable for holding maximum sum that can be       // obtained       long sum = 0;            // Loop for calculating initial sum of X[]       for (int i = 0; i < N; i++) {         sum += X[i];       }            // Start pointer for Y[]       int s = 0;            // End pointer of Y[]       int e = N - 1;            // Loop for Executing Queries in descending order of       // length       for (int i = list.Count - 1; i >= 0; i--) {              // Variable to hold length of subarray         int length = list[i];              // element needed to be add optimally         int element = length % 2 == 0 ? Y[s] : Y[e];              // Increasing or decreasing start and end         // pointers After using element at that pointers         if (length % 2 == 0) {           s++;         }         else {           e--;         }              // Condition when length is even         if (length % 2 == 0) {                // Subtracting from the           // overall sum           sum = sum - ((length / 2) * element);         }         else {                // Adding increment in           // overall sum           sum = sum + (((length + 1) / 2) * element);         }       }       // Printing value of sum       Console.Write(sum);     }           static public void Main()     {     // Driver code       int N = 3;       int[] X = { 1, 2, 3 };       int[] Y = { 4, 3, 1 };       int K = 2;            // Start[] and end[] of K length holds       // starting and ending indices       // of sub-array       int[] start = { 1, 1 };       int[] end = { 1, 3 };            // ArrayList of length of sub-arrays in each query       List<int> list=new List<int>();       for (int i = 0; i < K; i++) {         list.Add((end[i] - start[i]) + 1);       }            // Sorting ArrayList       list.Sort();            // Sorting Y[] using in-built sort function       Array.Sort(Y);               // Function call for getting maximum Sum       maximumSum(X, Y, N, K, list);          } }  // This code is contributed by ratiagrawal.

Output

Time Complexity: O(N²), As Selection Sort is used
Auxiliary Space: O(K), As ArrayList of Pair is used of Size K

Efficient Approach:

In this method, we will not be traversing on sub-array for each query. We will direct obtain the increment or decrement using a direct mathematical formula. From the intuition we can conclude that:

If length of sub-array is odd, Then increment in overall sum of X[] will be = (((length + 1) / 2) * element)
If the length of the sub-array is even, Then the decrement in overall sum of X[] will be = - ((length / 2) * element)

Here element is chosen element from Y[], and length is length of sub-array in query.

Follow the steps mentioned below to implement the idea:

Create a variable sum and calculate the overall sum of the elements initially present in X[].
Create a list and initialize it with the length of subarrays in K queries.
Sort list and the array Y[].
Run a loop from the back to the front of the list(Formally Descending order length) and do the following:
- If length is odd add (((length+1)/2)*element) in sum variable else subtract ((length/2)*element) from sum variable.
Print the value of the sum variable.

Below is the implementation of the above approach.

C++

// C++ code to implement the approach #include<bits/stdc++.h> using namespace std;  // Function to get maximum value after K // queries void maximumSum(int X[], int Y[], int N, int K,vector<int> &list) {   // Variable for holding maximum sum that can be   // obtained   long sum = 0;    // Loop for calculating initial sum of X[]   for (int i = 0; i < N; i++) {     sum += X[i];   }    // Start pointer for Y[]   int s = 0;    // End pointer of Y[]   int e = N - 1;    // Loop for Executing Queries in descending order of   // length   for (int i = list.size() - 1; i >= 0; i--) {      // Variable to hold length of subarray     int length = list[i];      // element needed to be add optimally     int element = length % 2 == 0 ? Y[s] : Y[e];      // Increasing or decreasing start and end     // pointers After using element at that pointers     if (length % 2 == 0) {       s++;     }     else {       e--;     }      // Condition when length is even     if (length % 2 == 0) {        // Subtracting from the       // overall sum       sum = sum - ((length / 2) * element);     }     else {        // Adding increment in       // overall sum       sum = sum + (((length + 1) / 2) * element);     }   }   // Printing value of sum   cout<<sum; }  // Driver code int main() {   int N = 3;   int X[] = { 1, 2, 3 };   int Y[] = { 4, 3, 1 };   int K = 2;    // Start[] and end[] of K length holds   // starting and ending indices   // of sub-array   int start[] = { 1, 1 };   int end[] = { 1, 3 };    // ArrayList of length of sub-arrays in each query   vector<int> list;   for (int i = 0; i < K; i++) {     list.push_back((end[i] - start[i]) + 1);   }    // Sorting ArrayList   sort(list.begin(),list.end());    // Sorting Y[] using in-built sort function   sort(Y,Y+N);    // Function call for getting maximum Sum   maximumSum(X, Y, N, K, list);    return 0; }  // This code is contributed by sanjoy_62.

Java

// Java code to implement the approach  import java.io.*; import java.lang.*; import java.util.*;  class GFG {      // Function to get maximum value after K     // queries     static void maximumSum(int X[], int Y[], int N, int K,                            ArrayList<Integer> list)     {         // Variable for holding maximum sum that can be         // obtained         long sum = 0;          // Loop for calculating initial sum of X[]         for (int i = 0; i < X.length; i++) {             sum += X[i];         }          // Start pointer for Y[]         int s = 0;          // End pointer of Y[]         int e = Y.length - 1;          // Loop for Executing Queries in descending order of         // length         for (int i = list.size() - 1; i >= 0; i--) {              // Variable to hold length of subarray             int length = list.get(i);              // element needed to be add optimally             int element = length % 2 == 0 ? Y[s] : Y[e];              // Increasing or decreasing start and end             // pointers After using element at that pointers             if (length % 2 == 0) {                 s++;             }             else {                 e--;             }              // Condition when length is even             if (length % 2 == 0) {                  // Subtracting from the                 // overall sum                 sum = sum - ((length / 2) * element);             }             else {                  // Adding increment in                 // overall sum                 sum = sum + (((length + 1) / 2) * element);             }         }         // Printing value of sum         System.out.println(sum);     }      // Driver code     public static void main(String[] args)     {         int N = 3;         int[] X = { 1, 2, 3 };         int[] Y = { 4, 3, 1 };         int K = 2;          // Start[] and end[] of K length holds         // starting and ending indices         // of sub-array         int[] start = { 1, 1 };         int[] end = { 1, 3 };          // ArrayList of length of sub-arrays in each query         ArrayList<Integer> list = new ArrayList<>();         for (int i = 0; i < K; i++) {             list.add((end[i] - start[i]) + 1);         }          // Sorting ArrayList         list.sort(null);          // Sorting Y[] using in-built sort function         Arrays.sort(Y);          // Function call for getting maximum Sum         maximumSum(X, Y, N, K, list);     } }

Python3

# Function to get maximum value after K # queries def maximumSum(X, Y, N, K, list):   # Variable for holding maximum sum that can be   # obtained   sum = 0    # Loop for calculating initial sum of X[]   for i in range(N):     sum += X[i]    # Start pointer for Y[]   s = 0    # End pointer of Y[]   e = N-1    # Loop for Executing Queries in descending order of   # length   for i in reversed(range(len(list))):     # Variable to hold length of subarray     length = list[i]      # element needed to be add optimally     element = Y[s] if length % 2 == 0 else Y[e]       # Increasing or decreasing start and end     # pointers After using element at that pointers     if length%2 == 0:       s += 1     else:       e -= 1      # Condition when length is even     if length%2 == 0:       # Subtracting from the       # overall sum       sum = sum - ((length/2) * element)     else:       # Adding increment in       # overall sum       sum = sum + (((length + 1) // 2) * element)      # Printing value of sum   print(sum)                     # Driver code  if __name__ == "__main__":    N = 3   X = [1, 2, 3]   Y = [4, 3, 1]   K = 2    # Start[] and end[] of K length holds   # starting and ending indices   # of sub-array   start = [1, 1]   end = [1, 3]    # ArrayList of length of sub-arrays in each query   list = []   for i in range(0, K):     list.append((end[i] - start[i]) + 1)    # Sorting ArrayList   list.sort()    # Sorting Y[] using in-built sort function   Y.sort()    # Function call for getting maximum Sum   maximumSum(X, Y, N, K, list)  # This code is contributed by sanjoy_62.

// C# code to implement the approach  using System; using System.Collections; using System.Collections.Generic;  public class GFG {    // Function to get maximum value after K   // queries   static void maximumSum(int[] X, int[] Y, int N, int K,                          ArrayList list)   {     // Variable for holding maximum sum that can be     // obtained     long sum = 0;      // Loop for calculating initial sum of X[]     for (int i = 0; i < X.Length; i++) {       sum += X[i];     }      // Start pointer for Y[]     int s = 0;      // End pointer of Y[]     int e = Y.Length - 1;      // Loop for Executing Queries in descending order of     // length     for (int i = list.Count - 1; i >= 0; i--) {        // Variable to hold length of subarray       int length = (int)list[i];        // element needed to be add optimally       int element = length % 2 == 0 ? Y[s] : Y[e];        // Increasing or decreasing start and end       // pointers After using element at that pointers       if (length % 2 == 0) {         s++;       }       else {         e--;       }        // Condition when length is even       if (length % 2 == 0) {          // Subtracting from the         // overall sum         sum = sum - ((length / 2) * element);       }       else {          // Adding increment in         // overall sum         sum = sum + (((length + 1) / 2) * element);       }     }     // Printing value of sum     Console.WriteLine(sum);   }    static public void Main()   {      // Code     int N = 3;     int[] X = { 1, 2, 3 };     int[] Y = { 4, 3, 1 };     int K = 2;      // Start[] and end[] of K length holds     // starting and ending indices     // of sub-array     int[] start = { 1, 1 };     int[] end = { 1, 3 };      // ArrayList of length of sub-arrays in each query     ArrayList list = new ArrayList();     for (int i = 0; i < K; i++) {       list.Add((end[i] - start[i]) + 1);     }      // Sorting ArrayList     list.Sort();      // Sorting Y[] using in-built sort function     Array.Sort(Y);      // Function call for getting maximum Sum     maximumSum(X, Y, N, K, list);   } }  // This code is contributed by lokesh

JavaScript

// Javascript code to implement the approach  // Function to get maximum value after K // queries function maximumSum(X, Y, N, K, list) {   // Variable for holding maximum sum that can be   // obtained   let sum = 0;    // Loop for calculating initial sum of X[]   for (let i = 0; i < N; i++) {     sum += X[i];   }    // Start pointer for Y[]   let s = 0;    // End pointer of Y[]   let e = N - 1;    // Loop for Executing Queries in descending order of   // length   for (let i = list.length - 1; i >= 0; i--) {      // Variable to hold length of subarray     let length = list[i];      // element needed to be add optimally     let element = length % 2 == 0 ? Y[s] : Y[e];      // Increasing or decreasing start and end     // pointers After using element at that pointers     if (length % 2 == 0) {       s++;     }     else {       e--;     }      // Condition when length is even     if (length % 2 == 0) {        // Subtracting from the       // overall sum       sum = sum - ((length / 2) * element);     }     else {        // Adding increment in       // overall sum       sum = sum + (((length + 1) / 2) * element);     }   }   // Printing value of sum   console.log(sum); }  // Driver code let N = 3; let X = [ 1, 2, 3 ]; let Y = [ 4, 3, 1 ]; let K = 2;  // Start[] and end[] of K length holds // starting and ending indices // of sub-array let start = [ 1, 1 ]; let end = [ 1, 3 ];  // ArrayList of length of sub-arrays in each query let list=new Array(); for (let i = 0; i < K; i++) {     list.push((end[i] - start[i]) + 1); }  // Sorting ArrayList list.sort();  // Sorting Y[] using in-built sort function Y.sort();  // Function call for getting maximum Sum maximumSum(X, Y, N, K, list);