 GeeksforGeeks App
Open App Browser
Continue

# 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:
Decrement arr 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 ``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

 ``

Output:

`11`

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

My Personal Notes arrow_drop_up