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

• Difficulty Level : Medium
• Last Updated : 17 Jul, 2021

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 ith 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 ith 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 to answer as we need at least arr 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 using namespace std; // Function to count the minimum// number of subarrays that are// required to be decremented by 1int min_operations(vector& A){    // Base Case    if (A.size() == 0)        return 0;     // Initialize ans to first element    int ans = A;     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 Codeint main(){    vector A{ 1, 2, 3, 2, 1 };     cout << min_operations(A) << "\n";     return 0;}

Java

 // Java Program to implement// the above approachimport 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;        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 1def min_operations(A):     # Base case    if len(A) == 0:        return 0     # Initializing ans to first element    ans = A    for i in range(1, len(A)):         if A[i] > A[i-1]:            ans += A[i]-A[i-1]     return ans  # Driver CodeA = [1, 2, 3, 2, 1]print(min_operations(A))

C#

 // C# program to implement// the above approachusing System; class GFG{ // Function to count the minimum// number of subarrays that are// required to be decremented by 1static int min_operations(int[] A, int n){         // Base Case    if (n == 0)        return 0;     // Initializing ans to first element    int ans = A;         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 Codepublic 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



Output:

3

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

My Personal Notes arrow_drop_up