# Minimize moves required to make array elements equal by incrementing and decrementing pairs | Set 2

• Difficulty Level : Expert
• Last Updated : 23 Jul, 2021

Given an array arr[] of size N, the task is to print the minimum number of moves required to make all array elements equal by selecting any pair of distinct indices and then increment the element at the first index and decrement the element at the other index by 1 each time. If it is impossible to make all array elements equal, then print “-1“.

Examples:

Input: arr[] = {5, 4, 1, 10}
Output: 5
Explanation:
One of the possible ways to perform operations is:
Operation 1: Select the indices 1 and 3 and then increment arr by 1 and decrement arr by 1. Thereafter, the array modifies to {5, 5, 1, 9}.
Operation 2: Select the indices 2 and 3 and then increment arr by 1 and decrement arr by 1. Thereafter, the array modifies to {5, 5, 2, 8}.
Operation 3: Select the indices 2 and 3 and then increment arr by 1 and decrement arr by 1. Thereafter, the array modifies to {5, 5, 3, 7}.
Operation 4: Select the indices 2 and 3 and then increment arr by 1 and decrement arr by 1. Thereafter, the array modifies to {5, 5, 4, 6}.
Operation 5: Select the indices 2 and 3 and then increment arr by 1 and decrement arr by 1. Thereafter, the array modifies to {5, 5, 5, 5}.
Therefore, the total number of moves needed is 5. Also, it is the minimum possible moves needed.

Input: arr[] = {1, 4}
Output: -1

Naive Approach: Refer to the previous post for the simplest approach to solve the problem.
Time Complexity: O(NlogN)
Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized based on the following observations:

• It can be observed that in each operation, the sum of the array remains the same. Therefore, if the sum of the array is not divisible N, then it is impossible to make all the array elements equal.
• Otherwise, each array element will be equal to the sum of the array divided by N, say k.
• Therefore, the idea is to iterate over the array and find the absolute difference between the current element and k and add to ans.
• Since in each operation, both increments and decrements are performed together, ans / 2 is the number of operations required.

Follow the steps below to solve the problem:

• Initialize a variable, say ans as 0, to store the count of the operations required.
• Find the sum of the array and store it in a variable, say sum.
• Now, if the sum is not divisible by N, then print “-1“. Otherwise, store k = sum / N.
• Initialize variables, say i = 0, and traverse the array.
• Iterate while i is less than N and add the absolute difference between the current element and k to ans:
• Finally, after completing the above steps, print ans / 2.

Below is the implementation of the above approach:

## C++

 `// cpp program for the above approach` `// Function to find the minimum number``// of increment and decrement of pairs``// required to make all array elements equal``#include``using` `namespace` `std;``int` `find(vector<``int``>arr, ``int` `N)``{` `    ``// Stores the sum of the array``    ``int` `Sum = 0;``    ``for``(``auto` `i:arr)``        ``Sum += i;` `    ``// If sum is not divisible by N``    ``if` `(Sum % N)``        ``return` `-1;``  ` `   ``// Update sum``    ``int` `k = Sum / N;``    ``int` `ans = 0;``  ` `    ``// Store the minimum``    ``// number of operations``    ``int` `i = 0;` `    ``// Iterate while i``    ``// is less than N``    ``while` `(i < N){` `        ``// Add absolute difference``        ``// of current element with``        ``// k to ans``        ``ans = ans + ``abs``(k-arr[i]);``      ` `        ``// Increase i bye 1``        ``i += 1;``    ``}``  ` `    ``// Return the value in ans//2``    ``return` `ans /2;``}`  `// Driver Code``int` `main()``{``  ` `    ``// Given Input``    ``vector<``int``>arr = {5, 4, 1, 10};``    ``int` `N = arr.size();``  ` `    ``// Function Call``    ``cout<<(find(arr, N));``}` `// This code is contributed by amreshkumar3.`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG``{` `static` `int` `find(ArrayListarr, ``int` `N)``{` `    ``// Stores the sum of the array``    ``int` `Sum = ``0``;``    ``for``(``int` `item : arr)``        ``Sum += item;` `    ``// If sum is not divisible by N``    ``if` `(Sum % N==``1``)``        ``return` `-``1``;``  ` `   ``// Update sum``    ``int` `k = Sum / N;``    ``int` `ans = ``0``;``  ` `    ``// Store the minimum``    ``// number of operations``    ``int` `i = ``0``;` `    ``// Iterate while i``    ``// is less than N``    ``while` `(i < N){` `        ``// Add absolute difference``        ``// of current element with``        ``// k to ans``        ``ans = ans + Math.abs(k-arr.get(i));``      ` `        ``// Increase i bye 1``        ``i += ``1``;``    ``}``  ` `    ``// Return the value in ans//2``    ``return` `ans /``2``;``}`  `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Given Input``    ``ArrayListarr = ``new` `ArrayList<>();``    ``arr.add(``5``);``    ``arr.add(``4``);``    ``arr.add(``1``);``    ``arr.add(``10``);``    ` `    ``int` `N = arr.size();``  ` `    ``// Function Call``    ``System.out.println(find(arr, N));``    ``}``}` `// This code is contributed by sanjoy_62.`

## Python3

 `# Python program for the above approach` `# Function to find the minimum number``# of increment and decrement of pairs``# required to make all array elements equal``def` `find(arr, N):` `    ``# Stores the sum of the array``    ``Sum` `=` `sum``(arr)` `    ``# If sum is not divisible by N``    ``if` `Sum` `%` `N:``        ``return` `-``1``    ``else``:` `       ``# Update sum``        ``k ``=` `Sum` `/``/` `N` `        ``# Store the minimum``        ``# number of operations``        ``ans ``=` `0` `        ``i ``=` `0` `        ``# Iterate while i``        ``# is less than N``        ``while` `i < N:` `            ``# Add absolute difference``            ``# of current element with``            ``# k to ans``            ``ans ``=` `ans ``+` `abs``(k``-``arr[i])` `            ``# Increase i bye 1``            ``i ``+``=` `1` `        ``# Return the value in ans//2``        ``return` `ans ``/``/` `2`  `# Driver Code``if` `__name__ ``=``=` `'__main__'``:` `    ``# Given Input``    ``arr ``=` `[``5``, ``4``, ``1``, ``10``]``    ``N ``=` `len``(arr)` `    ``# Function Call``    ``print``(find(arr, N))`

## C#

 `// C# program for the above approach` `// Function to find the minimum number``// of increment and decrement of pairs``// required to make all array elements equal``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `static` `int` `find(List<``int``>arr, ``int` `N)``{` `    ``// Stores the sum of the array``    ``int` `Sum = 0;``    ``foreach``(``int` `item ``in` `arr)``        ``Sum += item;` `    ``// If sum is not divisible by N``    ``if` `(Sum % N==1)``        ``return` `-1;``  ` `   ``// Update sum``    ``int` `k = Sum / N;``    ``int` `ans = 0;``  ` `    ``// Store the minimum``    ``// number of operations``    ``int` `i = 0;` `    ``// Iterate while i``    ``// is less than N``    ``while` `(i < N){` `        ``// Add absolute difference``        ``// of current element with``        ``// k to ans``        ``ans = ans + Math.Abs(k-arr[i]);``      ` `        ``// Increase i bye 1``        ``i += 1;``    ``}``  ` `    ``// Return the value in ans//2``    ``return` `ans /2;``}`  `// Driver Code``public` `static` `void` `Main()``{``  ` `    ``// Given Input``    ``List<``int``>arr = ``new` `List<``int``>(){5, 4, 1, 10};``    ``int` `N = arr.Count;``  ` `    ``// Function Call``    ``Console.Write(find(arr, N));``}``}` `// This code is contributed by bgangwar59.`

## Javascript

 ``

Output:

`5`

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

My Personal Notes arrow_drop_up