Minimum operations to make sum of neighbouring elements <= X

Given an array arr[] of N elements and an integer X, the task is to find the minimum number of operations required to make sum of neighbouring elements less than the given number X. In a single operation, you can choose an element arr[i] and decrease its value by 1.
Examples:

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 

Approach: Suppose the elements of the array are a1, a2, …, an. Let’s assume a case when all a[i] are greater than X. 
First we need to make all the a[i] equal to x. We will calculate the number of operations required for it. 
Now, all elements will be of the form of x, x, x, x…, x N times. Here we can observe that the maximum neighbouring sum is equal to 2 * X. 
Now, traverse the array from left to right, and for each i, if sum of two left neighbours that is a[i] + a[i – 1] > X then change a[i] to such a value that their net sum becomes equal to X. 
Below is the implementation of the above approach: 

C++

// C++ implementation of the approach
#include <bits/stdc++.h>
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 currently 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 currently 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 currently 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 currently 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

<script>
// 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 currently 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
</script>

Output:

11

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