 GeeksforGeeks App
Open App Browser
Continue

# 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``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

## 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

 ``

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``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

## 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

 ``

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