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

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 eb 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[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++
Java
Python
// 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;
}
Output:

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

#arrays #greedy #mathematical #searching #subarray

geeksforgeeks.org

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