使相邻元素之和<= X的最小运算

给定一个由N个元素组成的数组arr []和一个整数X ，任务是找到使相邻元素之和小于给定数量X所需的最小操作数。在单个操作中，您可以选择元素arr [i]并将其值减小1 。

例子：

Input: arr[] = {2, 2, 2}, X = 3
Output: 1
Decrement arr[1] by 1 and the array becomes {2, 1, 2}.
Now, 2 + 1 = 3 and 1 + 2 = 3

Input: arr[] = {1, 6, 1, 2, 0, 4}, X = 1
Output: 11

方法：假设数组的元素是a1，a2，…，an 。让我们假设所有a [i]都大于X的情况。
首先，我们需要使所有a [i]等于x 。我们将计算所需的操作次数。
现在，所有元素的形式均为x，x，x，x…，x N次。在这里，我们可以观察到最大相邻和等于2 * X。
现在，从左到右遍历该数组，对于每个i ，如果两个左邻居的和为a [i] + a [i – 1]> X，则将a [i]更改为这样一个值，即它们的净和等于X。

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
  
// Function to return the minimum
// number of operations required
int MinOperations(int n, int x, int* arr)
{
  
    // To store total operations required
    int total = 0;
    for (int i = 0; i < n; ++i) {
  
        // First make all elements equal to x
        // which are currenctly greater
        if (arr[i] > x) {
            int difference = arr[i] - x;
            total = total + difference;
            arr[i] = x;
        }
    }
  
    // Left scan the array
    for (int i = 1; i < n; ++i) {
        int LeftNeigbouringSum = arr[i] + arr[i - 1];
  
        // Update the current element such that
        // neighbouring sum is < x
        if (LeftNeigbouringSum > x) {
            int current_diff = LeftNeigbouringSum - x;
            arr[i] = max(0, arr[i] - current_diff);
            total = total + current_diff;
        }
    }
    return total;
}
  
// Driver code
int main()
{
    int X = 1;
    int arr[] = { 1, 6, 1, 2, 0, 4 };
    int N = sizeof(arr) / sizeof(int);
    cout << MinOperations(N, X, arr);
  
    return 0;
}

Java

// Java implementation of the approach
class GFG 
{
  
// Function to return the minimum
// number of operations required
static int MinOperations(int n, int x, int[] arr)
{
  
    // To store total operations required
    int total = 0;
    for (int i = 0; i < n; ++i) 
    {
  
        // First make all elements equal to x
        // which are currenctly greater
        if (arr[i] > x)
        {
            int difference = arr[i] - x;
            total = total + difference;
            arr[i] = x;
        }
    }
  
    // Left scan the array
    for (int i = 1; i < n; ++i)
    {
        int LeftNeigbouringSum = arr[i] + arr[i - 1];
  
        // Update the current element such that
        // neighbouring sum is < x
        if (LeftNeigbouringSum > x) 
        {
            int current_diff = LeftNeigbouringSum - x;
            arr[i] = Math.max(0, arr[i] - current_diff);
            total = total + current_diff;
        }
    }
    return total;
}
  
// Driver code
public static void main(String args[]) 
{
    int X = 1;
    int arr[] = { 1, 6, 1, 2, 0, 4 };
    int N = arr.length;
    System.out.println(MinOperations(N, X, arr));
}
}
  
// This code is contributed by 29AjayKumar

Python

# Python3 implementation of the approach
  
# Function to return the minimum
# number of operations required
def MinOperations(n, x, arr):
  
    # To store total operations required
    total = 0
    for i in range(n):
  
        # First make all elements equal to x
        # which are currenctly greater
        if (arr[i] > x):
            difference = arr[i] - x
            total = total + difference
            arr[i] = x
  
  
    # Left scan the array
    for i in range(n):
        LeftNeigbouringSum = arr[i] + arr[i - 1]
  
        # Update the current element such that
        # neighbouring sum is < x
        if (LeftNeigbouringSum > x):
            current_diff = LeftNeigbouringSum - x
            arr[i] = max(0, arr[i] - current_diff)
            total = total + current_diff
  
    return total
  
  
# Driver code
X = 1
arr=[1, 6, 1, 2, 0, 4 ]
N = len(arr)
print(MinOperations(N, X, arr))
  
# This code is contributed by mohit kumar 29

C#

// C# implementation of the approach 
using System;
      
class GFG 
{
  
// Function to return the minimum
// number of operations required
static int MinOperations(int n, int x, int[] arr)
{
  
    // To store total operations required
    int total = 0;
    for (int i = 0; i < n; ++i) 
    {
  
        // First make all elements equal to x
        // which are currenctly greater
        if (arr[i] > x)
        {
            int difference = arr[i] - x;
            total = total + difference;
            arr[i] = x;
        }
    }
  
    // Left scan the array
    for (int i = 1; i < n; ++i)
    {
        int LeftNeigbouringSum = arr[i] + arr[i - 1];
  
        // Update the current element such that
        // neighbouring sum is < x
        if (LeftNeigbouringSum > x) 
        {
            int current_diff = LeftNeigbouringSum - x;
            arr[i] = Math.Max(0, arr[i] - current_diff);
            total = total + current_diff;
        }
    }
    return total;
}
  
// Driver code
public static void Main(String []args) 
{
    int X = 1;
    int []arr = { 1, 6, 1, 2, 0, 4 };
    int N = arr.Length;
    Console.WriteLine(MinOperations(N, X, arr));
}
}
  
/* This code is contributed by PrinciRaj1992 */

输出：

11