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: 4 
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: 0 
Explanation: 
The array is already non-increasing 

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++ Program to implement
// the above approach
#include <bits/stdc++.h>
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[0]);
    cout << getMinOps(arr, N);
}

// This code is contributed by shikhasingrajput

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

<script>

// javascript program for the above approach

    // Function to find the minimum
    // number of operations required to
    // make the array non-increasing
    function getMinOps(arr) {
        // Stores the count of
        // required operations
        var res = 0;

        for (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
    
        var arr = [ 1, 3, 4, 1, 2 ];
        document.write(getMinOps(arr));

// This code contributed by umadevi9616

</script>

4

Time Complexity: O(N) 
Auxiliary Space: O(1)