Minimice el recuento de incrementos de cada elemento de los subarreglos necesarios para que Array no aumente

Dado un arreglo arr[] que consta de N enteros, la tarea es encontrar el número mínimo de operaciones, lo que implica incrementar todos los elementos de un subarreglo en 1, necesarios para que el arreglo no aumente.
Ejemplos:  

Entrada: arr[] = {1, 3, 4, 1, 2} 
Salida: 4 
Explicación: 
En la operación 1: Elija el subarreglo {1} y aumente su valor en 1. Ahora arr[] = {2, 3, 4 , 1, 2} 
En la operación 2: Elija el subarreglo {2} y aumente su valor en 1. Ahora arr[] = {3, 3, 4, 1, 2} 
En la operación 3: Elija el subarreglo {3, 3} y aumente su valor en 1. Ahora arr[] = {4, 4, 4, 1, 2} 
En la operación 4: Elija el subarreglo {1} y aumente su valor en 1. Ahora arr[] = {4, 4, 4, 2, 2} 
Por lo tanto, se necesitaron 4 operaciones para que la array no fuera creciente.

Entrada: arr[] = {10, 9, 8, 7, 7} 
Salida: 0 
Explicación: 
la array ya no es creciente 

Enfoque: El enfoque se basa en el hecho de que las operaciones solo se pueden realizar en subarreglos. Por lo tanto, solo verifique los elementos contiguos. A continuación se muestran los pasos:

1. De lo contrario, inicialice una variable, digamos res , para almacenar la cantidad de operaciones requeridas.
2. Ahora, recorra la array y para cada elemento, verifique si el elemento en el índice i es más pequeño que el elemento en el índice (i + 1) . Si se determina que es cierto, agregue la diferencia entre ellos a res , ya que ambos elementos deben igualarse para que la array no aumente.
3. De lo contrario, pase al siguiente elemento y repita los pasos anteriores.
4. Finalmente, después de completar el recorrido de la array, imprima el valor final de res .

A continuación se muestra la implementación del enfoque anterior:

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

Complejidad temporal: O(N) 
Espacio auxiliar: O(1)