Related Articles

# Maximum element present in the array after performing queries to add K to range of indices [L, R]

• Last Updated : 12 Jul, 2021

Given an array arr[] consisting of N integers, ( initially set to 0 ) and an array Q[], consisting of queries of the form {l, r, k}, the task for each query is to add K to the indices l to r(both inclusive). After performing all queries, return the maximum element present the array.

Example:

Input: N=10, q[] = {{1, 5, 3}, {4, 8, 7}, {6, 9, 1}}
Output: 10
Explanation:
Initially the array is → [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Query1 {1, 5, 3} results in [3, 3, 3, 3, 3, 0, 0, 0, 0, 0]
Query2 {4, 8, 7} results in [3, 3, 3, 10, 10, 7, 7, 7, 0, 0]
Query2 {6, 9, 1} results in [3, 3, 3, 10, 10, 8, 8, 8, 1, 0]
Maximum value in the updated array = 10

Approach: Follow the steps below to solve the problem.

• Traverse over the vector of queries  and for each query {l, r, k}
• Add k to a[l] and subtract k from a[r+1]
• Initialize variable x = 0 to store the running sum and m = INT_MIN to store the maximum value
• Traverse the array, add elements to x, and update m.
• Print the maximum value m

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;``// Function to find the max sum``// after processing q queries``int` `max_sum(``int` `a[],``            ``vector, ``int``> > v,``            ``int` `q, ``int` `n)``{``    ``// Store the cumulative sum``    ``int` `x = 0;``    ``// Store the maximum sum``    ``int` `m = INT_MIN;` `    ``// Iterate over the range 0 to q``    ``for` `(``int` `i = 0; i < q; i++) {` `        ``// Variables to extract``        ``// values from vector``        ``int` `p, q, k;` `        ``p = v[i].first.first;``        ``q = v[i].first.second;``        ``k = v[i].second;``        ``a[p] += k;` `        ``if` `(q + 1 <= n)` `            ``a[q + 1] -= k;``    ``}` `    ``// Iterate over the range [1, n]``    ``for` `(``int` `i = 1; i <= n; i++)` `    ``{``        ``// Calculate cumulative sum``        ``x += a[i];` `        ``// Calculate maximum sum``        ``m = max(m, x);``    ``}``    ``// Return the maximum sum after q queries``    ``return` `m;``}` `// Driver code``int` `main()``{` `    ``// Stores the size of array``    ``// and number of queries``    ``int` `n = 10, q = 3;` `    ``// Stores the sum``    ``int` `a[n + 5] = { 0 };` `    ``// Storing input queries``    ``vector, ``int``> > v(q);``    ``v[0].first.first = 1;``    ``v[0].first.second = 5;``    ``v[0].second = 3;``    ``v[1].first.first = 4;``    ``v[1].first.second = 8;``    ``v[1].second = 7;``    ``v[2].first.first = 6;``    ``v[2].first.second = 9;``    ``v[2].second = 1;` `    ``// Function call to find the maximum sum``    ``cout << max_sum(a, v, q, n);``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.lang.*;``import` `java.util.*;` `class` `GFG{``    ` `// Function to find the max sum``// after processing q queries``static` `int` `max_sum(``int` `a[],``                   ``ArrayList> v,``                   ``int` `q, ``int` `n)``{``    ` `    ``// Store the cumulative sum``    ``int` `x = ``0``;``    ` `    ``// Store the maximum sum``    ``int` `m = Integer.MIN_VALUE;` `    ``// Iterate over the range 0 to q``    ``for``(``int` `i = ``0``; i < q; i++)``    ``{``        ` `        ``// Variables to extract``        ``// values from vector``        ``int` `p, qq, k;` `        ``p = v.get(i).get(``0``);``        ``qq = v.get(i).get(``1``);``        ``k = v.get(i).get(``2``);``        ``a[p] += k;` `        ``if` `(qq + ``1` `<= n)``            ``a[qq + ``1``] -= k;``    ``}` `    ``// Iterate over the range [1, n]``    ``for``(``int` `i = ``1``; i <= n; i++)``    ``{``        ` `        ``// Calculate cumulative sum``        ``x += a[i];` `        ``// Calculate maximum sum``        ``m = Math.max(m, x);``    ``}``    ` `    ``// Return the maximum sum after q queries``    ``return` `m;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Stores the size of array``    ``// and number of queries``    ``int` `n = ``10``, q = ``3``;``    ` `    ``// Stores the sum``    ``int``[] a = ``new` `int``[n + ``5``];``    ` `    ``// Storing input queries``    ``ArrayList> v= ``new` `ArrayList<>();``    ` `    ``for``(``int` `i = ``0``; i < q; i++)``        ``v.add(``new` `ArrayList<>());``    ` `    ``v.get(``0``).add(``1``);``    ``v.get(``0``).add(``5``);``    ``v.get(``0``).add(``3``);``    ``v.get(``1``).add(``4``);``    ``v.get(``1``).add(``8``);``    ``v.get(``1``).add(``7``);``    ``v.get(``2``).add(``6``);``    ``v.get(``2``).add(``9``);``    ``v.get(``2``).add(``1``);``    ` `    ``// Function call to find the maximum sum``    ``System.out.println(max_sum(a, v, q, n));``}``}` `// This code is contributed by offbeat`

## Python3

 `# Python program for the above approach` `# Function to find the max sum``# after processing q queries``def` `max_sum(a, v, q, n):``  ` `    ``# Store the cumulative sum``    ``x ``=` `0``;``    ` `    ``# Store the maximum sum``    ``m ``=` `-``10``*``*``9``;` `    ``# Iterate over the range 0 to q``    ``for` `i ``in` `range``(q):` `        ``# Variables to extract``        ``# values from vector``        ``p ``=` `v[i][``0``][``0``];``        ``q ``=` `v[i][``0``][``1``];``        ``k ``=` `v[i][``1``];``        ``a[p] ``+``=` `k;` `        ``if` `(q ``+` `1` `<``=` `n):``            ``a[q ``+` `1``] ``-``=` `k;` `    ``# Iterate over the range [1, n]``    ``for` `i ``in` `range``(``1``, n ``+` `1``):``        ``# Calculate cumulative sum``        ``x ``+``=` `a[i];` `        ``# Calculate maximum sum``        ``m ``=` `max``(m, x);` `    ``# Return the maximum sum after q queries``    ``return` `m;` `# Driver code` `# Stores the size of array``# and number of queries``n ``=` `10``q ``=` `3``;` `# Stores the sum``a ``=` `[``0``] ``*` `(n ``+` `5``);` `# Storing input queries``v ``=` `[[[``0` `for` `i ``in` `range``(``2``)] ``for` `x ``in` `range``(``2``)] ``for` `z ``in` `range``(q)]``v[``0``][``0``][``0``] ``=` `1``;``v[``0``][``0``][``1``] ``=` `5``;``v[``0``][``1``] ``=` `3``;``v[``1``][``0``][``0``] ``=` `4``;``v[``1``][``0``][``1``] ``=` `8``;``v[``1``][``1``] ``=` `7``;``v[``2``][``0``][``0``] ``=` `6``;``v[``2``][``0``][``1``] ``=` `9``;``v[``2``][``1``] ``=` `1``;` `# Function call to find the maximum sum``print``(max_sum(a, v, q, n));` `# This code is contributed by _saurabh_jaiswal`

## Javascript

 ``
Output:
`10`

Time Complexity: O(N+K) where N is the size of array and K is a number of queries
Space Complexity: O(1)

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