Skip to content
Related Articles
Get the best out of our app
GeeksforGeeks App
Open App
geeksforgeeks
Browser
Continue

Related Articles

Minimum operations to make sum of neighbouring elements <= X

Improve Article
Save Article
Like Article
Improve Article
Save Article
Like Article

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:
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)


My Personal Notes arrow_drop_up
Last Updated : 18 Jan, 2023
Like Article
Save Article
Similar Reads
Related Tutorials