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

给定一个由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]的增加操作，对于剩余的值，我们增加它通过(a[i]-a[i-1])操作来自(i..(n-1)) 。
• 因此，遍历数组，对于第一个之后的每个元素，将连续对的绝对差添加到答案中。
• 最后，打印答案。

下面是上述方法的实现：

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)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live