# Minimum number of steps required to obtain the given Array by the given operations

Given an array arr[] of N positive integers, the task is to find the minimum number of operations required of the following types to obtain the array arr[] from an array of zeroes only.

• Select any index i and increment all the elements at the indices [i, N – 1] by 1.
• Select any index i and decrease all the elements at the indices [i, N – 1] by 1.

Examples:

Input: arr[]={1,1,2,2,1}
Output:
Explanation:
Initially arr[] = {0,0,0,0,0}
Step 1: arr[]={1,1,1,1,1}(Operation 1 on index 0)
Step 2: arr[]={1,1,2,2,2}(Operation 1 on index 2)
Step 3: arr[]={1,1,2,2,1}(Operation 2 on index 4)
Input: arr[]={1,2,3,4}
Output:

Naive Approach: The simplest approach is to convert each element of the array result array, brr[] to arr[] by performing one of the above operations over the indices [i, N – 1] and increase the count of each operation performed.
Time Complexity: O(N2
Auxiliary Space: O(1)
Efficient Approach:
The above approach can be optimized using Greedy Approach
Follow the steps below to solve the problem:

• For the 0th index, convert the number 0 to arr. Therefore, the number of steps required will always be a. Hence, add arr to the answer.
• For all the other indices, the common greedy observation is to use the increase or the decrease operation by abs(a[i]-a[i-1]) times.
• The intuition behind this approach is, if the number is less than a[i-1], then increase everything from ((i-1).. n-1) by a[i], and then decrease (a[i-1] – a[i]) to get a[i].
• If a[i] > a[i-1], the approach is to use the increase operation from ((i-1)..n-1) by a[i-1], and for the remaining value, we increase it by (a[i]-a[i-1]) operations from (i..(n-1)).
• Therefore, traverse the array and for every element after the first, add the absolute difference of consecutive pairs to the answer.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement` `// the above approach` `#include ` `using` `namespace` `std;`   `// Function to calculate the minimum` `// steps to obtain the desired array` `int` `min_operation(``int` `a[], ``int` `n)` `{` `    ``// Initialize variable` `    ``int` `ans = 0;`   `    ``// Iterate over the array arr[]` `    ``for` `(``int` `i = 0; i < n; i++) {`   `        ``// Check if i > 0` `        ``if` `(i > 0)`   `            ``// Update the answer` `            ``ans += ``abs``(a[i] - a[i - 1]);`   `        ``else` `            ``ans += ``abs``(a[i]);` `    ``}`   `    ``// Return the result` `    ``return` `ans;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 1, 2, 3, 4 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);`   `    ``cout << min_operation(arr, n);`   `    ``return` `0;` `}`

## Java

 `// Java Program to implement` `// the above approach` `import` `java.util.*;` `class` `GFG{`   `// Function to calculate the minimum` `// steps to obtain the desired array` `static` `int` `min_operation(``int` `a[], ``int` `n)` `{` `    ``// Initialize variable` `    ``int` `ans = ``0``;`   `    ``// Iterate over the array arr[]` `    ``for` `(``int` `i = ``0``; i < n; i++)` `    ``{`   `        ``// Check if i > 0` `        ``if` `(i > ``0``)`   `            ``// Update the answer` `            ``ans += Math.abs(a[i] - a[i - ``1``]);`   `        ``else` `            ``ans += Math.abs(a[i]);` `    ``}`   `    ``// Return the result` `    ``return` `ans;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `arr[] = { ``1``, ``2``, ``3``, ``4` `};` `    ``int` `n = arr.length;`   `    ``System.out.print(min_operation(arr, n));` `}` `}`   `// This code is contributed by gauravrajput1`

## Python3

 `# Python3 program to implement` `# the above approach`   `# Function to calculate the minimum` `# steps to obtain the desired array` `def` `min_operation(a, n):`   `    ``# Initialize variable` `    ``ans ``=` `0`   `    ``# Iterate over the array arr[]` `    ``for` `i ``in` `range``(n):`   `        ``# Check if i > 0` `        ``if` `(i > ``0``):`   `            ``# Update the answer` `            ``ans ``+``=` `abs``(a[i] ``-` `a[i ``-` `1``])` `        ``else``:` `            ``ans ``+``=` `abs``(a[i])`   `    ``# Return the result` `    ``return` `ans`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``arr ``=` `[ ``1``, ``2``, ``3``, ``4` `]` `    ``n ``=` `len``(arr)`   `    ``print``(min_operation(arr, n))`   `# This code is contributed by chitranayal`

## C#

 `// C# Program to implement` `// the above approach` `using` `System;` `class` `GFG{`   `// Function to calculate the minimum` `// steps to obtain the desired array` `static` `int` `min_operation(``int` `[]a, ``int` `n)` `{` `    ``// Initialize variable` `    ``int` `ans = 0;`   `    ``// Iterate over the array []arr` `    ``for` `(``int` `i = 0; i < n; i++)` `    ``{`   `        ``// Check if i > 0` `        ``if` `(i > 0)`   `            ``// Update the answer` `            ``ans += Math.Abs(a[i] - a[i - 1]);`   `        ``else` `            ``ans += Math.Abs(a[i]);` `    ``}`   `    ``// Return the result` `    ``return` `ans;` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `[]arr = { 1, 2, 3, 4 };` `    ``int` `n = arr.Length;`   `    ``Console.Write(min_operation(arr, n));` `}` `}`   `// This code is contributed by Amit Katiyar`

Output:

```4

```

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

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.