Minimum Decrements on Subarrays required to reduce all Array elements to zero

Last Updated : 11 Jul, 2022

Given an array arr[] consisting of N non-negative integers, the task is to find the minimum number of subarrays that needs to be reduced by 1 such that all the array elements are equal to 0.

Example:

Input: arr[] = {1, 2, 3, 2, 1}
Output: 3
Explanation:
Operation 1: {1, 2, 3, 2, 1} -> {0, 1, 2, 1, 0}
Operation 2: {0, 1, 2, 1, 0} -> {0, 0, 1, 0, 0}
Operation 3: {0, 0, 1, 0, 0} -> {0, 0, 0, 0, 0}

Input: arr[] = {5, 4, 3, 4, 4}
Output: 6
Explanation:
{5, 4, 3, 4, 4} -> {4, 3, 2, 3, 3} -> {3, 2, 1, 2, 2} -> {2, 1, 0, 1, 1} -> {2, 1, 0, 0, 0} -> {1, 0, 0, 0, 0} -> {0, 0, 0, 0, 0}

Approach:
This can be optimally done by traversing the given array from index 0, finding the answer up to index i, where 0 ? i < N. If arr[i] ? arr[i+1], then (i + 1)^th element can be included in every subarray operation of i^th element, thus requiring no extra operations. If arr[i] < arr[i + 1], then (i + 1)^th element can be included in every subarray operation of i^th element and after all operations, arr[i+1] becomes arr[i+1]-arr[i]. Therefore, we need arr[i+1]-arr[i] extra operations to reduce it zero.

Follow the below steps to solve the problem:

Add the first element arr[0] to answer as we need at least arr[0] to make the given array 0.
Traverse over indices [1, N-1] and for every element, check if it is greater than the previous element. If found to be true, add their difference to the answer.

Below is the implementation of above approach:

C++

   // C++ Program to implement  
// the above approach  
#include <bits/stdc++.h>  
using namespace std;  
  
// Function to count the minimum  
// number of subarrays that are  
// required to be decremented by 1  
int min_operations(vector<int>& A)  
{  
    // Base Case  
    if (A.size() == 0)  
        return 0;  
  
    // Initialize ans to first element  
    int ans = A[0];  
  
    for (int i = 1; i < A.size(); i++) {  
  
        // For A[i] > A[i-1], operation  
        // (A[i] - A[i - 1]) is required  
        ans += max(A[i] - A[i - 1], 0);  
    }  
  
    // Return the answer  
    return ans;  
}  
  
// Driver Code  
int main()  
{  
    vector<int> A{ 1, 2, 3, 2, 1 };  
  
    cout << min_operations(A) << "\n";  
  
    return 0;  
}  
 
  

Java

   // Java Program to implement  
// the above approach  
import java.io.*;  
  
class GFG {  
  
    // Function to count the minimum  
    // number of subarrays that are  
    // required to be decremented by 1  
    static int min_operations(int A[], int n)  
    {  
        // Base Case  
        if (n == 0)  
            return 0;  
  
        // Initializing ans to first element  
        int ans = A[0];  
        for (int i = 1; i < n; i++) {  
  
            // For A[i] > A[i-1], operation  
            // (A[i] - A[i - 1]) is required  
            if (A[i] > A[i - 1]) {  
                ans += A[i] - A[i - 1];  
            }  
        }  
  
        // Return the count  
        return ans;  
    }  
  
    // Driver Code  
    public static void main(String[] args)  
    {  
        int n = 5;  
        int A[] = { 1, 2, 3, 2, 1 };  
        System.out.println(min_operations(A, n));  
    }  
}  
 
  

Python

   # Python Program to implement  
# the above approach  
  
# Function to count the minimum  
# number of subarrays that are  
# required to be decremented by 1  
def min_operations(A):  
  
    # Base case  
    if len(A) == 0:  
        return 0
  
    # Initializing ans to first element  
    ans = A[0]  
    for i in range(1, len(A)):  
  
        if A[i] > A[i-1]:  
            ans += A[i]-A[i-1]  
  
    return ans  
  
  
# Driver Code  
A = [1, 2, 3, 2, 1]  
print(min_operations(A))  
 
  

C#

   // C# program to implement 
// the above approach 
using System; 
  
class GFG{ 
  
// Function to count the minimum 
// number of subarrays that are 
// required to be decremented by 1 
static int min_operations(int[] A, int n) 
{ 
      
    // Base Case 
    if (n == 0) 
        return 0; 
  
    // Initializing ans to first element 
    int ans = A[0]; 
      
    for(int i = 1; i < n; i++)  
    { 
          
        // For A[i] > A[i-1], operation 
        // (A[i] - A[i - 1]) is required 
        if (A[i] > A[i - 1])  
        { 
            ans += A[i] - A[i - 1]; 
        } 
    } 
      
    // Return the count 
    return ans; 
} 
  
// Driver Code 
public static void Main() 
{ 
    int n = 5; 
    int[] A = { 1, 2, 3, 2, 1 }; 
      
    Console.WriteLine(min_operations(A, n)); 
} 
} 
  
// This code is contributed by bolliranadheer
 
  

Javascript

   <script> 
  
// Javascript program to implement  
// the above approach  
  
// Function to count the minimum  
// number of subarrays that are  
// required to be decremented by 1  
function min_operations(A)  
{  
      
    // Base Case  
    if (A.length == 0)  
        return 0;  
  
    // Initialize ans to first element  
    let ans = A[0];  
  
    for(let i = 1; i < A.length; i++) 
    {  
          
        // For A[i] > A[i-1], operation  
        // (A[i] - A[i - 1]) is required  
        ans += Math.max(A[i] - A[i - 1], 0);  
    }  
  
    // Return the answer  
    return ans;  
}  
  
// Driver Code  
let A = [ 1, 2, 3, 2, 1 ];  
document.write(min_operations(A));  
  
// This code is contributed by subhammahato348 
  
</script>
 
  

Output:

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

Minimum steps required to reduce all array elements to 1 based on given steps

dp82

Improve

Article Tags :

Practice Tags :

Minimum Decrements on Subarrays required to reduce all Array elements to zero

C++

Java

Python

C#

Javascript

Similar Reads