通过给定操作获得给定Array所需的最小步骤数

给定N个正整数的数组arr [] ，任务是找到以下类型的最小操作数，以仅从零数组中获取数组arr [] 。

• 选择任何索引i并将索引[i，N – 1]上的所有元素加1 。
• 选择任何索引i并将索引[i，N – 1]上的所有元素减少1 。

例子：

Input: arr[]={1,1,2,2,1} 
Output: 3 
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: 4 
 

天真的方法：最简单的方法是通过对索引[i，N – 1]执行上述操作之一，并将数组结果数组brr []的每个元素转换为arr [] ，并增加执行的每个操作的计数。
时间复杂度： O(N ² )
辅助空间： O(1)

高效的方法：可以使用贪婪方法对上述方法进行优化。请按照以下步骤解决问题：

• 对于第0^个索引，将数字0转换为arr [0] 。因此，所需的步数将始终为a [0] 。因此，将arr [0]添加到答案中。
• 对于所有其他索引，通常的贪婪观察是使用abs(a [i] -a [i-1])次的增加或减少操作。
• 这种方法的直觉是，如果数量小于a [i-1] ，则将((i-1).. n-1)的所有内容增加a [i] ，然后减小(a [i- 1] – a [i])以获得a [i]。
• 如果a [i]> a [i-1] ，则方法是使用从((i-1).. n-1)乘a [i-1]的加法运算，对于剩余值，我们增加通过( i ..(n-1))的(a [i] -a [i-1])运算来实现。
• 因此，遍历数组，对于第一个元素之后的每个元素，将连续对的绝对差值添加到answer中。
• 最后，打印答案。

下面是上述方法的实现：

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[0]);
 
    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

Javascript

// javascript Program to implement
// the above approach
 
    // Function to calculate the minimum
    // steps to obtain the desired array
    function min_operation(a , n) {
        // Initialize variable
        var ans = 0;
 
        // Iterate over the array arr
        for (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
     
        var arr = [ 1, 2, 3, 4 ];
        var n = arr.length;
 
        document.write(min_operation(arr, n));
 
// This code contributed by Rajput-Ji

输出：

4

时间复杂度： O(N)
辅助空间： O(1)