Skip to content
Related Articles

Related Articles

Improve Article

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 <bits/stdc++.h>
using namespace std;
// Function to find the max sum
// after processing q queries
int max_sum(int a[],
            vector<pair<pair<int, int>, 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<pair<pair<int, int>, 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<ArrayList<Integer>> 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<ArrayList<Integer>> 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




<script>
// Javascript program for the above approach
 
 
// Function to find the max sum
// after processing q queries
function max_sum(a, v, q, n) {
    // Store the cumulative sum
    let x = 0;
    // Store the maximum sum
    let m = Number.MIN_SAFE_INTEGER;
 
    // Iterate over the range 0 to q
    for (let i = 0; i < q; i++) {
 
        // Variables to extract
        // values from vector
        let p, q, k;
 
        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 (let 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
 
 
// Stores the size of array
// and number of queries
let n = 10, q = 3;
 
// Stores the sum
let a = new Array(n + 5).fill(0);
 
// Storing input queries
let v = new Array(q).fill(0).map(() => new Array(2).fill(0).map(() => new Array(2).fill(0)));
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
document.write(max_sum(a, v, q, n));
 
// This code is contributed by gfgking.
</script>
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
Recommended Articles
Page :