使相邻元素之和 <= 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 */

Javascript

// Javascript implementation of the approach
 
// Function to return the minimum
// number of operations required
function MinOperations(n, x, arr)
{
 
    // To store total operations required
    let total = 0;
    for (let i = 0; i < n; ++i)
    {
   
        // First make all elements equal to x
        // which are currenctly greater
        if (arr[i] > x)
        {
            let difference = arr[i] - x;
            total = total + difference;
            arr[i] = x;
        }
    }
   
    // Left scan the array
    for (let i = 1; i < n; ++i)
    {
        let LeftNeigbouringSum = arr[i] + arr[i - 1];
   
        // Update the current element such that
        // neighbouring sum is < x
        if (LeftNeigbouringSum > x)
        {
            let current_diff = LeftNeigbouringSum - x;
            arr[i] = Math.max(0, arr[i] - current_diff);
            total = total + current_diff;
        }
    }
    return total;
}
 
// Driver code
let X = 1;
let arr = [ 1, 6, 1, 2, 0, 4 ];
let N = arr.length;
document.write(MinOperations(N, X, arr)+"<br>");
 
// This code is contributed by rag2127

输出：

11

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。