Maximize subarray sum of given Array by adding X in range [L, R] for Q queries
Last Updated :
06 Dec, 2021
Given an array arr[] of N integers and M update queries of the type (L, R, X), the task is to find the maximum subarray sum after each update query where in each query, add integer X to every element of the array arr[] in the range [L, R].
Examples:
Input: arr[] = {-1, 5, -2, 9, 3, -3, 2}, query[] = {{0, 2, -10}, {4, 5, 2}}
Output: 12 15
Explanation: Below are the steps to solve the above example:
- The array after 1st update query becomes arr[] = {-11, -5, -12, 9, 3, -3, 2}. Hence the maximum subarray sum is 12 of the subarray arr[3… 4].
- The array after 2nd update query becomes arr[] = {-11, -5, -12, 9, 5, -1, 2}. Hence the maximum subarray sum is 15 of the subarray arr[3… 6].
Input: arr[] = {-2, -5, 6, -2, -3, 1, 5, -6, 4, -1}, query[] = {{1, 4, 3}, {4, 5, -4}, {7, 9, 5}}
Output: 16 10 20
Approach: The given problem can be solved using Kadane’s Algorithm. For each query, update the array elements by traversing over all the elements of the array arr[] in the range [L, R] and add integer X to each element. After every update query, calculate the maximum subarray sum using the algorithm discussed here.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int maxSubarraySum( int arr[], int n)
{
int maxSum = INT_MIN;
int currSum = 0;
for ( int i = 0; i <= n - 1; i++) {
currSum += arr[i];
if (currSum > maxSum) {
maxSum = currSum;
}
if (currSum < 0) {
currSum = 0;
}
}
return maxSum;
}
void updateArr( int * arr, int L, int R, int X)
{
for ( int i = L; i <= R; i++) {
arr[i] += X;
}
}
void maxSubarraySumQuery(
int arr[], int n,
vector<vector< int > > query)
{
for ( int i = 0; i < query.size(); i++) {
updateArr(arr, query[i][0],
query[i][1],
query[i][2]);
cout << maxSubarraySum(arr, n) << " " ;
}
}
int main()
{
int arr[] = { -2, -5, 6, -2, -3,
1, 5, -6, 4, -1 };
int N = sizeof (arr) / sizeof (arr[0]);
vector<vector< int > > query{ { 1, 4, 3 },
{ 4, 5, -4 },
{ 7, 9, 5 } };
maxSubarraySumQuery(arr, N, query);
return 0;
}
|
Java
class GFG {
public static int maxSubarraySum( int arr[], int n)
{
int maxSum = Integer.MIN_VALUE;
int currSum = 0 ;
for ( int i = 0 ; i <= n - 1 ; i++) {
currSum += arr[i];
if (currSum > maxSum) {
maxSum = currSum;
}
if (currSum < 0 ) {
currSum = 0 ;
}
}
return maxSum;
}
public static void updateArr( int [] arr, int L,
int R, int X)
{
for ( int i = L; i <= R; i++) {
arr[i] += X;
}
}
public static void maxSubarraySumQuery( int arr[], int n, int [][] query)
{
for ( int i = 0 ; i < query.length; i++)
{
updateArr(arr, query[i][ 0 ],
query[i][ 1 ],
query[i][ 2 ]);
System.out.print(maxSubarraySum(arr, n) + " " );
}
}
public static void main(String args[])
{
int arr[] = { - 2 , - 5 , 6 , - 2 , - 3 ,
1 , 5 , - 6 , 4 , - 1 };
int N = arr.length;
int [][] query = { { 1 , 4 , 3 }, { 4 , 5 , - 4 }, { 7 , 9 , 5 } };
maxSubarraySumQuery(arr, N, query);
}
}
|
Python3
def maxSubarraySum(arr, n):
maxSum = 10 * * - 9
currSum = 0
for i in range (n):
currSum + = arr[i]
if (currSum > maxSum):
maxSum = currSum
if (currSum < 0 ):
currSum = 0
return maxSum
def updateArr(arr, L, R, X):
for i in range (L, R + 1 ):
arr[i] + = X
def maxSubarraySumQuery(arr, n, query):
for i in range ( len (query)):
updateArr(arr, query[i][ 0 ],
query[i][ 1 ],
query[i][ 2 ])
print (maxSubarraySum(arr, n), end = " " )
arr = [ - 2 , - 5 , 6 , - 2 , - 3 , 1 , 5 , - 6 , 4 , - 1 ]
N = len (arr)
query = [[ 1 , 4 , 3 ],[ 4 , 5 , - 4 ],[ 7 , 9 , 5 ]]
maxSubarraySumQuery(arr, N, query)
|
C#
using System;
class GFG
{
public static int maxSubarraySum( int [] arr, int n)
{
int maxSum = int .MinValue;
int currSum = 0;
for ( int i = 0; i <= n - 1; i++)
{
currSum += arr[i];
if (currSum > maxSum)
{
maxSum = currSum;
}
if (currSum < 0)
{
currSum = 0;
}
}
return maxSum;
}
public static void updateArr( int [] arr, int L,
int R, int X)
{
for ( int i = L; i <= R; i++)
{
arr[i] += X;
}
}
public static void maxSubarraySumQuery( int [] arr, int n, int [,] query)
{
for ( int i = 0; i < query.Length; i++)
{
updateArr(arr, query[i, 0],
query[i, 1],
query[i, 2]);
Console.Write(maxSubarraySum(arr, n) + " " );
}
}
public static void Main()
{
int [] arr = { -2, -5, 6, -2, -3, 1, 5, -6, 4, -1 };
int N = arr.Length;
int [,] query = { { 1, 4, 3 }, { 4, 5, -4 }, { 7, 9, 5 } };
maxSubarraySumQuery(arr, N, query);
}
}
|
Javascript
<script>
function maxSubarraySum(arr, n)
{
let maxSum = Number.MIN_VALUE;
let currSum = 0;
for (let i = 0; i <= n - 1; i++) {
currSum += arr[i];
if (currSum > maxSum) {
maxSum = currSum;
}
if (currSum < 0) {
currSum = 0;
}
}
return maxSum;
}
function updateArr(arr, L, R, X) {
for (let i = L; i <= R; i++) {
arr[i] += X;
}
}
function maxSubarraySumQuery(
arr, n,
query) {
for (let i = 0; i < query.length; i++) {
updateArr(arr, query[i][0],
query[i][1],
query[i][2]);
document.write(maxSubarraySum(arr, n) + " " );
}
}
let arr = [-2, -5, 6, -2, -3,
1, 5, -6, 4, -1];
let N = arr.length;
let query = [[1, 4, 3],
[4, 5, -4],
[7, 9, 5]];
maxSubarraySumQuery(arr, N, query);
</script>
|
Time Complexity: O(N*M)
Auxiliary Space: O(1)
Share your thoughts in the comments
Please Login to comment...