# Minimize count of increments of each element of subarrays required to make Array non-increasing

Given an array arr[] consisting of N integers, the task is to find the minimum number of operations, which involves incrementing all elements of a subarray by 1, required to make the array non-increasing.
Examples:

Input: arr[] = {1, 3, 4, 1, 2}
Output:
Explanation:
In operation 1: Choose the subarray {1} and increase its value by 1. Now arr[] = {2, 3, 4, 1, 2}
In operation 2: Choose the subarray {2} and increase its value by 1. Now arr[] = {3, 3, 4, 1, 2}
In operation 3: Choose the subarray {3, 3} and increase its value by 1. Now arr[] = {4, 4, 4, 1, 2}
In operation 4: Choose the subarray {1} and increase its value by 1. Now arr[] = {4, 4, 4, 2, 2}
Thus, it took 4 operations to make the array non-increasing.

Input: arr[] = {10, 9, 8, 7, 7}
Output:
Explanation:

Approach: The approach is based on the fact that the operations can only be performed on subarrays. So only check for contiguous elements. Below are the steps:

1. Otherwise, initialize a variable, say res, to store the count of operations required.
2. Now, traverse the array and for each element, check if the element at index i is smaller than the element at index (i + 1). If found to be true, then add the difference between them to res, since both the elements need to be made equal to make the array non-increasing.
3. Otherwise, move to the next element and repeat the above steps.
4. Finally, after complete the traversal of the array, print the final value of res.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement` `// the above approach` `#include ` `using` `namespace` `std;`   `// Function to find the minimum` `// number of operations required to` `// make the array non-increasing` `int` `getMinOps(``int` `arr[], ``int` `n)` `{` `  `  `    ``// Stores the count of` `    ``// required operations` `    ``int` `res = 0;`   `    ``for` `(``int` `i = 0; i < n - 1; i++) ` `    ``{`   `        ``// If arr[i] > arr[i+1],` `        ``// no increments required.` `        ``// Otherwise, add their` `        ``// difference to the answer` `        ``res += max(arr[i + 1] - arr[i], 0);` `    ``}`   `    ``// Return the result res` `    ``return` `res;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = {1, 3, 4, 1, 2};` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``cout << getMinOps(arr, N);` `}`   `// This code is contributed by shikhasingrajput`

## Java

 `// Java program for the above approach` `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {`   `    ``// Function to find the minimum` `    ``// number of operations required to` `    ``// make the array non-increasing` `    ``public` `static` `int` `getMinOps(``int``[] arr)` `    ``{` `        ``// Stores the count of` `        ``// required operations` `        ``int` `res = ``0``;`   `        ``for` `(``int` `i = ``0``;` `             ``i < arr.length - ``1``; i++) ` `        ``{`   `            ``// If arr[i] > arr[i+1],` `            ``// no increments required.` `            ``// Otherwise, add their` `            ``// difference to the answer` `            ``res += Math.max(arr[i + ``1``]` `                            ``- arr[i],` `                            ``0``);` `        ``}`   `        ``// Return the result res` `        ``return` `res;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int``[] arr = { ``1``, ``3``, ``4``, ``1``, ``2` `};` `        ``System.out.println(getMinOps(arr));` `    ``}` `}`

## Python3

 `# Python3 Program to implement` `# the above approach`   `# Function to find the minimum` `# number of operations required to` `# make the array non-increasing` `def` `getMinOps(arr):`   `    ``# Stores the count of` `    ``# required operations` `    ``res ``=` `0`   `    ``for` `i ``in` `range``(``len``(arr) ``-` `1``):` `      `  `        ``# If arr[i] > arr[i+1],` `        ``# no increments required.` `        ``# Otherwise, add their` `        ``# difference to the answer` `        ``res ``+``=` `max``(arr[i ``+` `1``] ``-` `arr[i], ``0``)`   `    ``# Return the result res ` `    ``return` `res`   `# Driver Code`   `# Given array` `arr ``=` `[ ``1``, ``3``, ``4``, ``1``, ``2` `]`   `# Function call` `print``(getMinOps(arr))`   `# This code is contributed by Shivam Singh`

## C#

 `// C# program for the above approach` `using` `System;`   `class` `GFG{`   `// Function to find the minimum` `// number of operations required to` `// make the array non-increasing` `public` `static` `int` `getMinOps(``int``[] arr)` `{` `    `  `    ``// Stores the count of` `    ``// required operations` `    ``int` `res = 0;`   `    ``for``(``int` `i = 0; i < arr.Length - 1; i++) ` `    ``{` `        `  `        ``// If arr[i] > arr[i+1],` `        ``// no increments required.` `        ``// Otherwise, add their` `        ``// difference to the answer` `        ``res += Math.Max(arr[i + 1] - ` `                        ``arr[i], 0);` `    ``}`   `    ``// Return the result res` `    ``return` `res;` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``int``[] arr = { 1, 3, 4, 1, 2 };` `    `  `    ``Console.WriteLine(getMinOps(arr));` `}` `}`   `// This code is contributed by 29AjayKumar`

Output:

```4

```

Time Complexity: O(N)
Auxiliary Space: 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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.