Skip to content
Related Articles

Related Articles

Maximum value in an array after m range increment operations

View Discussion
Improve Article
Save Article
  • Difficulty Level : Hard
  • Last Updated : 23 Sep, 2022
View Discussion
Improve Article
Save Article

Consider an array of size n with all initial values as 0. We need to perform the following m range increment operations.

increment(a, b, k) : Increment values from 'a'
                     to 'b' by 'k'.    

After m operations, we need to calculate the maximum of the values in the array.

Examples:

Input : n = 5 m = 3 
           a = 0, b = 1, k = 100 
           a = 1, b = 4, k = 100
           a = 2, b = 3, k = 100
Output : 200
Explanation:
Initially array = {0, 0, 0, 0, 0}
After first operation:
array = {100, 100, 0, 0, 0}
After second operation:
array = {100, 200, 100, 100, 100}
After third operation:
array = {100, 200, 200, 200, 100}
Maximum element after m operations is 200.

Input : n = 4 m = 3 
            a = 1, b = 2, k = 603
            a = 0, b = 0, k = 286
            a = 3, b = 3, k = 882
Output : 882
Explanation:
Initially array = {0, 0, 0, 0}
After first operation:
array = {0, 603, 603, 0}
After second operation:
array = {286, 603, 603, 0}
After third operation:
array = {286, 603, 603, 882}
Maximum element after m operations is 882.

A naive method is to perform each operation on the given range and then, at last, find the maximum number.

C++




// C++ implementation of simple approach to
// find maximum value after m range increments.
#include<bits/stdc++.h>
using namespace std;
 
// Function to find the maximum element after
// m operations
int findMax(int n, int a[], int b[], int k[], int m)
{
    int arr[n];
    memset(arr, 0, sizeof(arr));
 
    // start performing m operations
    for (int i = 0; i< m; i++)
    {
        // Store lower and upper index i.e. range
        int lowerbound = a[i];
        int upperbound = b[i];
 
        // Add 'k[i]' value at this operation to
        // whole range
        for (int j=lowerbound; j<=upperbound; j++)
            arr[j] += k[i];
    }
 
    // Find maximum value after all operations and
    // return
    int res = INT_MIN;
    for (int i=0; i<n; i++)
        res = max(res, arr[i]);
 
    return res;
}
 
// Driver code
int main()
{
    // Number of values
    int n = 5;
    int a[] = {0, 1, 2};
    int b[] = {1, 4, 3};
 
    // value of k to be added at each operation
    int k[] = {100, 100, 100};
 
    int m = sizeof(a)/sizeof(a[0]);
 
    cout << "Maximum value after 'm' operations is "
        << findMax(n, a, b, k, m);
    return 0;
}


Java




// Java implementation of simple approach
// to find maximum value after m range
// increments.
import java.util.*;
 
class GFG{
     
// Function to find the maximum element after
// m operations
static int findMax(int n, int a[],
                   int b[], int k[], int m)
{
    int[] arr = new int[n];
 
    // Start performing m operations
    for(int i = 0; i < m; i++)
    {
         
        // Store lower and upper index i.e. range
        int lowerbound = a[i];
        int upperbound = b[i];
 
        // Add 'k[i]' value at this operation to
        // whole range
        for(int j = lowerbound; j <= upperbound; j++)
            arr[j] += k[i];
    }
 
    // Find maximum value after all
    // operations and return
    int res = Integer.MIN_VALUE;
    for(int i = 0; i < n; i++)
        res = Math.max(res, arr[i]);
 
    return res;
}
 
// Driver Code
public static void main (String[] args)
{
     
    // Number of values
    int n = 5;
    int a[] = { 0, 1, 2 };
    int b[] = { 1, 4, 3 };
     
    // Value of k to be added at
    // each operation
    int k[] = { 100, 100, 100 };
     
    int m = a.length;
     
    System.out.println("Maximum value after 'm' " +
                       "operations is " +
                       findMax(n, a, b, k, m));
}
}
 
// This code is contributed by offbeat


Python3




# Python3 program of
# simple approach to
# find maximum value
# after m range increments.
import sys
 
# Function to find the
# maximum element after
# m operations
def findMax(n, a, b, k, m):
 
  arr = [0] * n
 
  # Start performing m operations
  for i in range(m):
     
    # Store lower and upper
    # index i.e. range
    lowerbound = a[i]
    upperbound = b[i]
 
    # Add 'k[i]' value at
    # this operation to whole range
    for j in range (lowerbound,
                    upperbound + 1):
      arr[j] += k[i]
 
      # Find maximum value after
      # all operations and return
      res = -sys.maxsize - 1
       
      for i in range(n):
        res = max(res, arr[i])
        return res
  
# Driver code
if __name__ == "__main__":
 
  # Number of values
  n = 5
  a = [0, 1, 2]
  b = [1, 4, 3]
 
  # Value of k to be added
  # at each operation
  k = [100, 100, 100]
 
  m = len(a)
 
  print ("Maximum value after 'm' operations is ",
          findMax(n, a, b, k, m))
  
# This code is contributed by Chitranayal


C#




// C# implementation of simple approach
// to find maximum value after m range
// increments.
using System;
public class GFG
{
 
  // Function to find the maximum element after
  // m operations
  static int findMax(int n, int[] a,
                     int[] b, int[] k, int m)
  {
    int[] arr = new int[n];
 
    // Start performing m operations
    for(int i = 0; i < m; i++)
    {
 
      // Store lower and upper index i.e. range
      int lowerbound = a[i];
      int upperbound = b[i];
 
      // Add 'k[i]' value at this operation to
      // whole range
      for(int j = lowerbound; j <= upperbound; j++)
        arr[j] += k[i];
    }
 
    // Find maximum value after all
    // operations and return
    int res = Int32.MinValue;
    for(int i = 0; i < n; i++)
      res = Math.Max(res, arr[i]);
 
    return res;
  }
 
  // Driver Code
  static public void Main ()
  {
 
    // Number of values
    int n = 5;
    int[] a = { 0, 1, 2 };
    int[] b = { 1, 4, 3 };
 
    // Value of k to be added at
    // each operation
    int[] k = { 100, 100, 100 };
 
    int m = a.Length;
 
    Console.WriteLine("Maximum value after 'm' " +
                      "operations is " +
                      findMax(n, a, b, k, m));
  }
}
 
// This code is contributed by avanitrachhadiya2155


Javascript




<script>
    // Javascript implementation of simple approach
    // to find maximum value after m range
    // increments.
     
    // Function to find the maximum element after
    // m operations
    function findMax(n, a, b, k, m)
    {
      let arr = new Array(n);
      arr.fill(0);
 
      // Start performing m operations
      for(let i = 0; i < m; i++)
      {
 
        // Store lower and upper index i.e. range
        let lowerbound = a[i];
        let upperbound = b[i];
 
        // Add 'k[i]' value at this operation to
        // whole range
        for(let j = lowerbound; j <= upperbound; j++)
          arr[j] += k[i];
      }
 
      // Find maximum value after all
      // operations and return
      let res = Number.MIN_VALUE;
      for(let i = 0; i < n; i++)
        res = Math.max(res, arr[i]);
 
      return res;
    }
     
    // Number of values
    let n = 5;
    let a = [ 0, 1, 2 ];
    let b = [ 1, 4, 3 ];
  
    // Value of k to be added at
    // each operation
    let k = [ 100, 100, 100 ];
  
    let m = a.length;
  
    document.write("Maximum value after 'm' " +
                      "operations is " +
                      findMax(n, a, b, k, m));
  
 // This code is contributed by rameshtravel07.
</script>


Output

Maximum value after 'm' operations is 200

Time Complexity: O(m * max(range)). Here max(range) means maximum elements to which k is added in a single operation.
Auxiliary space: O(n) 

Efficient method: The idea is similar to this post.

Perform two things in a single operation: 

  1. Add k-value to the only lower_bound of a range. 
  2. Reduce the upper_bound + 1 index by a k-value.

After all operations, add all values, check the maximum sum, and print the maximum sum.

C++




// C++ implementation of simple approach to
// find maximum value after m range increments.
#include<bits/stdc++.h>
using namespace std;
 
// Function to find maximum value after 'm' operations
int findMax(int n, int m, int a[], int b[], int k[])
{
    int arr[n+1];
    memset(arr, 0, sizeof(arr));
 
    // Start performing 'm' operations
    for (int i=0; i<m; i++)
    {
        // Store lower and upper index i.e. range
        int lowerbound = a[i];
        int upperbound = b[i];
 
        // Add k to the lower_bound
        arr[lowerbound] += k[i];
 
        // Reduce upper_bound+1 indexed value by k
        arr[upperbound+1] -= k[i];
    }
 
    // Find maximum sum possible from all values
    long long sum = 0, res = INT_MIN;
    for (int i=0; i < n; ++i)
    {
        sum += arr[i];
        res = max(res, sum);
    }
 
    // return maximum value
    return res;
}
 
// Driver code
int main()
{
    // Number of values
    int n = 5;
 
    int a[] = {0, 1, 2};
    int b[] = {1, 4, 3};
    int k[] = {100, 100, 100};
 
    // m is number of operations.
    int m = sizeof(a)/sizeof(a[0]);
 
    cout << "Maximum value after 'm' operations is "
         << findMax(n, m, a, b, k);
    return 0;
}


Java




// Java implementation of
// simple approach to
// find maximum value after
// m range increments.
import java.io.*;
 
class GFG
{
     
// Function to find maximum
// value after 'm' operations
static long findMax(int n, int m,
                    int a[], int b[],
                    int k[])
{
    int []arr = new int[n + 1];
    //memset(arr, 0, sizeof(arr));
 
    // Start performing 'm' operations
    for (int i = 0; i < m; i++)
    {
        // Store lower and upper
        // index i.e. range
        int lowerbound = a[i];
        int upperbound = b[i];
 
        // Add k to the lower_bound
        arr[lowerbound] += k[i];
 
        // Reduce upper_bound+1
        // indexed value by k
        arr[upperbound + 1] -= k[i];
    }
 
    // Find maximum sum
    // possible from all values
    long sum = 0, res = Integer.MIN_VALUE;
    for (int i = 0; i < n; ++i)
    {
        sum += arr[i];
        res = Math.max(res, sum);
    }
 
    // return maximum value
    return res;
}
 
// Driver code
public static void main (String[] args)
{
    // Number of values
    int n = 5;
     
    int a[] = {0, 1, 2};
    int b[] = {1, 4, 3};
    int k[] = {100, 100, 100};
     
    // m is number of operations.
    int m = a.length;
     
    System.out.println("Maximum value after "+
                        "'m' operations is " +
                      findMax(n, m, a, b, k));
    }
}
 
// This code is contributed by anuj_67.


Python3




# Java implementation of
# simple approach to
# find maximum value after
#  m range increments.
import sys
def findMax(n, m, a, b, k):
    arr = [ 0 for i in range(n + 1)]
     
    for i in range(m):
        lowerbound = a[i]
        upperbound = b[i]
         
        arr[lowerbound] += k[i]
        arr[upperbound + 1] -= k[i]
         
    sum = 0
    res = -1-sys.maxsize
         
    for i in range(n):
        sum += arr[i]
        res = max(res, sum)
    return res
     
n = 5
a = [0, 1, 2]
b = [1, 4, 3]
k = [100, 100, 100]
 
m = len(a)
         
print("Maximum value after","'m' operations is", findMax(n, m, a, b, k))
 
# This code is contributed by rag2127


C#




// c# implementation of
// simple approach to
// find maximum value after
// m range increments.
using System.Collections.Generic;
using System;
class GFG{
     
// Function to find maximum
// value after 'm' operations
static long findMax(int n, int m,
                    int []a, int []b,
                    int []k)
{
  int []arr = new int[n + 1];
   
  // Start performing 'm'
  // operations
  for (int i = 0; i < m; i++)
  {
    // Store lower and upper
    // index i.e. range
    int lowerbound = a[i];
    int upperbound = b[i];
 
    // Add k to the lower_bound
    arr[lowerbound] += k[i];
 
    // Reduce upper_bound+1
    // indexed value by k
    arr[upperbound + 1] -= k[i];
  }
 
  // Find maximum sum
  // possible from all values
  long sum = 0, res = -10000000;
   
  for (int i = 0; i < n; ++i)
  {
    sum += arr[i];
    res = Math.Max(res, sum);
  }
 
  // return maximum value
  return res;
}
 
// Driver code
public static void Main ()
{
  // Number of values
  int n = 5;
 
  int []a = {0, 1, 2};
  int []b = {1, 4, 3};
  int []k = {100, 100, 100};
 
  // m is number of operations.
  int m = a.Length;
 
  Console.WriteLine("Maximum value after " +
                    "'m' operations is " +
                     findMax(n, m, a, b, k));
}
}
 
// This code is contributed by Stream_Cipher


Javascript




<script>
    // Javascript implementation of
    // simple approach to
    // find maximum value after
    // m range increments.
     
    // Function to find maximum
    // value after 'm' operations
    function findMax(n, m, a, b, k)
    {
      let arr = new Array(n + 1);
      arr.fill(0);
 
      // Start performing 'm'
      // operations
      for (let i = 0; i < m; i++)
      {
        // Store lower and upper
        // index i.e. range
        let lowerbound = a[i];
        let upperbound = b[i];
 
        // Add k to the lower_bound
        arr[lowerbound] += k[i];
 
        // Reduce upper_bound+1
        // indexed value by k
        arr[upperbound + 1] -= k[i];
      }
 
      // Find maximum sum
      // possible from all values
      let sum = 0, res = -10000000;
 
      for (let i = 0; i < n; ++i)
      {
        sum += arr[i];
        res = Math.max(res, sum);
      }
 
      // return maximum value
      return res;
    }
     
    // Number of values
    let n = 5;
 
    let a = [0, 1, 2];
    let b = [1, 4, 3];
    let k = [100, 100, 100];
 
    // m is number of operations.
    let m = a.length;
 
    document.write("Maximum value after " +
                      "'m' operations is " +
                       findMax(n, m, a, b, k));
       
</script>


Output

Maximum value after 'm' operations is 200

Time complexity: O(m + n)
Auxiliary space: O(n)

This article is contributed by Sahil Chhabra. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!