Maximum value in an array after m range increment operations

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.