Minimize subtraction followed by increments of adjacent elements required to make all array elements equal
Last Updated :
08 Feb, 2023
Given an array arr[] consisting of N positive integers, the task is to make all array elements equal by repeatedly subtracting 1 from any number of array elements and add it to one of the adjacent elements at the same time. If all array elements can’t be made equal, then print “-1”. Otherwise, print the minimum count of operations required.
Examples:
Input: arr[] = {1, 0, 5}
Output: 3
Explanation:
Operation 1: Subtract arr[2](= 5) by 1 and add it to arr[1](= 0). Therefore, the array arr[] modifies to {1, 1, 4}.
Operation 2: Subtract arr[2](= 4) by 1 and add it to arr[1](= 1). Therefore, the array arr[] modifies to {1, 2, 3}.
Operation 3: Subtract arr[2](= 3) and arr[1](= 2) by 1 and add it to arr[1](= 1) and arr[2](= 2) respectively. Therefore, the array arr[] modifies to {2, 2, 2}.
Therefore, the minimum number of operations required is 3.
Input: arr[] = {0, 3, 0}
Output: 2
Approach: The given problem can be solved based on the following observation:
- All the array elements can be made equal if and only if the value of all array elements is equal to the average of the array.
- Since only 1 can be subtracted from an array element at a time, the minimum number of moves is the maximum of the prefix sum of the array or the number of moves required to make each element equal to the average of the array.
Follow the steps below to solve the problem:
- Calculate the sum of the elements of the array arr[], say S.
- If the sum S is not divisible by N, then print “-1”.
- Otherwise, perform the following operations:
- Store the average of array elements in a variable, say avg.
- Initialize two variables, say total and count with 0, to store the required result and the prefix sum of minimum moves to achieve avg respectively.
- Traverse the given array arr[] and perform the following steps:
- Add the value of (arr[i] – avg) to the count.
- Update the value of total to the maximum of the absolute value of count, total, (arr[i] – avg).
- After completing the above step, print the value of total as the resultant minimum operation required.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int findMinMoves(int arr[], int N)
{
int sum = 0;
for (int i = 0; i < N; i++)
sum += arr[i];
if (sum % N != 0)
return -1;
int avg = sum / N;
int total = 0;
int needCount = 0;
for (int i = 0; i < N; i++) {
needCount += (arr[i] - avg);
total
= max({abs(needCount),arr[i] - avg,total});
}
return total;
}
int main()
{
int arr[] = { 1, 0, 5 };
int N = sizeof(arr) / sizeof(arr[0]);
cout << findMinMoves(arr, N);
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG{
static int findMinMoves(int[] arr, int N)
{
int sum = 0;
for(int i = 0; i < N; i++)
sum += arr[i];
if (sum % N != 0)
return -1;
int avg = sum / N;
int total = 0;
int needCount = 0;
for(int i = 0; i < N; i++)
{
needCount += (arr[i] - avg);
total = Math.max(
Math.max(Math.abs(needCount),
arr[i] - avg), total);
}
return total;
}
public static void main(String[] args)
{
int[] arr = { 1, 0, 5 };
int N = arr.length;
System.out.println(findMinMoves(arr, N));
}
}
|
Python3
def findMinMoves(arr, N):
sum = 0
for i in range(N):
sum += arr[i]
if(sum % N != 0):
return -1
avg = sum // N
total = 0
needCount = 0
for i in range(N):
needCount += (arr[i] - avg)
total = max(max(abs(needCount), arr[i] - avg), total)
return total
if __name__ == '__main__':
arr = [1, 0, 5]
N = len(arr)
print(findMinMoves(arr, N))
|
C#
using System;
class GFG{
static int findMinMoves(int[] arr, int N)
{
int sum = 0;
for(int i = 0; i < N; i++)
sum += arr[i];
if (sum % N != 0)
return -1;
int avg = sum / N;
int total = 0;
int needCount = 0;
for(int i = 0; i < N; i++)
{
needCount += (arr[i] - avg);
total = Math.Max(
Math.Max(Math.Abs(needCount),
arr[i] - avg), total);
}
return total;
}
public static void Main()
{
int[] arr = { 1, 0, 5 };
int N = arr.Length;
Console.Write(findMinMoves(arr, N));
}
}
|
Javascript
<script>
function findMinMoves(arr, N)
{
let sum = 0;
for(let i = 0; i < N; i++)
sum += arr[i];
if (sum % N != 0)
return -1;
let avg = sum / N;
let total = 0;
let needCount = 0;
for(let i = 0; i < N; i++)
{
needCount += (arr[i] - avg);
total = Math.max(Math.max(
Math.abs(needCount),
arr[i] - avg), total);
}
return total;
}
let arr = [ 1, 0, 5 ];
let N = arr.length;
document.write(findMinMoves(arr, N))
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(1)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...