# 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 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; ` `} ` |

*chevron_right*

*filter_none*

## 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 ` |

*chevron_right*

*filter_none*

## 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 ` |

*chevron_right*

*filter_none*

## 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 */` |

*chevron_right*

*filter_none*

**Output:**

11

## Recommended Posts:

- Minimum increment by k operations to make all elements equal
- Minimum operations to make GCD of array a multiple of k
- Minimum operations to make frequency of all characters equal K
- Minimum operations required to make every element greater than or equal to K
- Minimum operations of the given type required to make a complete graph
- Minimum number of operations required to delete all elements of the array
- Make array elements equal in Minimum Steps
- Minimum steps to reach end from start by performing multiplication and mod operations with array elements
- Minimum Increment / decrement to make array elements equal
- Minimum value of X to make all array elements equal by either decreasing or increasing by X
- Minimum number of elements that should be removed to make the array good
- Minimum number of operations required to reduce N to 1
- Minimum cost to reach a point N from 0 with two different operations allowed
- Maximum sum of all elements of array after performing given operations
- Minimum number of operations to convert a given sequence into a Geometric Progression

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.