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++ 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 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 |
# 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# 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 */ |
<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> |
11
Time complexity: O(N)
Auxiliary Space: O(1)