GFG App
Open App
Browser
Continue

Count minimum decrement prefix or suffix or increment all operations to make Array equal to 0

Given an array arr[] of size N. The task is to make all the array elements equal to zero by applying the minimum number of operations.
Following operations are allowed:

1. Select an index i and decrease each element by 1 for the prefix up to that index.
2. Select an index i and decrease each element by 1 for the suffix starting from that index.
3. Increase all the elements of the array by 1.

Examples:

Input: arr[] = {2, 4, 6, 3, 7}
Output: Minimum operations: 12
Explanation: Select Index 0, and decrease all the elements from
index 1 to 4 by 2 in 2 operations, new arr[] would be {2, 2, 4, 1, 5}.
Select Index 1, and decrease all the elements from index 2 to 4
by 2 in 2 operations, new arr[] would be {2, 2, 2, -1, 3}
Select Index 3, and decrease all the elements from index 0 to 2
by 3 in 3 operations, new arr[] would be {-1, -1, -1, -1, 3}
Select Index 3, and decrease element of index 4 by 4 in 4 operations,
New arr[] would be {-1, -1, -1, -1, -1}
Increase all the elements by 1 in 1 operation,
Final arr[] would be {0, 0, 0, 0, 0}
Total, operations would be 2 + 2 + 3 + 4 + 1 = 12

Input: arr[] = {1, 3, 5, 7, 5, 2, 8}
Output: Minimum operations:  21

Approach:

The following problem can be solved using Greedy Approach

Initially make all elements equal to the first element and then decrement them to have value as 0.

To do this following steps can be taken:

• For making all the elements equal to the first element, we will use the difference between the consecutive elements. ( arr[i+1]  – arr[i] ).
• If the difference (diff = arr[i+1]  –  arr[i]) is positive, decrease the elements of suffix starting from index (i+1)
• Number of operations required = abs( diff )
• If the difference (diff = arr[i+1]  –  arr[i]) is negative, decrease the elements of prefix up to index i
• Number of operations required = abs( diff ) . Decreasing the prefix will also decrease the first element of the array by abs( diff).
• Finally, the total number of required operations will be operations calculated through the absolute difference between the consecutive elements of the array plus the absolute value of the first element of the array.

Below is the implementation of the above approach:

C++14

 // C++ code to implement the approach   #include using namespace std;   // Function to find  minimum number of // operations required to make all // array elements zero int minimumOperations(int arr[], int n) {     int i;       // It will count total no. of operations     int operations = 0;       for (int i = 0; i < n - 1; i++) {           // Calculate the difference and         // add its absolute value to         // the no. of operations         operations += abs(arr[i + 1] - arr[i]);           // If the changes are done in prefix         // then update first element of array         if (arr[i + 1] - arr[i] < 0) {             arr[0] -= (abs(arr[i + 1] - arr[i]));         }     }       // Now all the elements of the array are     // equal to arr[0], add absolute value     // of arr[0] to the no. of operations     operations += abs(arr[0]);       // Return the total number of operations     return operations; }   // Driver code int main() {     int arr[] = { 2, 4, 6, 3, 7 };     int N = sizeof(arr) / sizeof(arr[0]);       // Function call     cout << "Minimum operations: "          << minimumOperations(arr, N);     return 0; }

Java

 // Java program to of the above approach import java.util.*; class GFG {   // Function to find  minimum number of // operations required to make all // array elements zero static int minimumOperations(int arr[], int n) {     int i;       // It will count total no. of operations     int operations = 0;       for (i = 0; i < n - 1; i++) {           // Calculate the difference and         // add its absolute value to         // the no. of operations         operations += Math.abs(arr[i + 1] - arr[i]);           // If the changes are done in prefix         // then update first element of array         if (arr[i + 1] - arr[i] < 0) {             arr[0] -= (Math.abs(arr[i + 1] - arr[i]));         }     }       // Now all the elements of the array are     // equal to arr[0], add absolute value     // of arr[0] to the no. of operations     operations += Math.abs(arr[0]);       // Return the total number of operations     return operations; }   // Driver Code public static void main(String args[]) {     int arr[] = { 2, 4, 6, 3, 7 };     int N = arr.length;       // Function call     System.out.print("Minimum operations: "          + minimumOperations(arr, N)); } }   // This code is contributed by sanjoy_62.

Python3

 # Python code to implement the approach   # Function to find minimum number of # operations required to make all # array elements zero def minimumOperations(arr, n):     i = 0           # It will count total no. of operations     operations = 0     for i in range(n-1):                 # Calculate the difference and         # add its absolute value to         # the no. of operations         operations += abs(arr[i + 1] - arr[i])                   # If the changes are done in prefix         # then update first element of array         if (arr[i + 1] - arr[i]) < 0:             arr[0] -= (abs(arr[i + 1] - arr[i]))           # Now all the elements of the array are         # equal to arr[0], add absolute value         # of arr[0] to the no. of operations     operations += abs(arr[0])       # Return the total number of operations     return operations   # Driver code if __name__ == "__main__":     arr = [2, 4, 6, 3, 7]     N = 5     # Function call     print("Minimum operations: ", minimumOperations(arr, N))   # This code is contributed by Rohit Pradhan



C#

 // C# code to implement the approach using System; using System.Collections.Generic;   public class GFG {   // Function to find  minimum number of // operations required to make all // array elements zero static int minimumOperations(int[] arr, int n) {     int i;        // It will count total no. of operations     int operations = 0;        for (i = 0; i < n - 1; i++) {            // Calculate the difference and         // add its absolute value to         // the no. of operations         operations += Math.Abs(arr[i + 1] - arr[i]);            // If the changes are done in prefix         // then update first element of array         if (arr[i + 1] - arr[i] < 0) {             arr[0] -= (Math.Abs(arr[i + 1] - arr[i]));         }     }        // Now all the elements of the array are     // equal to arr[0], add absolute value     // of arr[0] to the no. of operations     operations += Math.Abs(arr[0]);        // Return the total number of operations     return operations; }       // Driver Code public static void Main(string[] args) {       int[] arr = { 2, 4, 6, 3, 7 };     int N = arr.Length;        // Function call     Console.WriteLine("Minimum operations: "          + minimumOperations(arr, N)); } }

Output

Minimum operations: 12

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

My Personal Notes arrow_drop_up