 GeeksforGeeks App
Open App Browser
Continue

# Minimum sum of all differences between unique pairs in the Array

Given an array arr[] consisting of N integers, the task is to find the minimum sum of all absolute differences between unique pairs of elements in the array after updating the array arr[]. To update the array, any two elements from the array can be chosen in any order. 1 is subtracted from the first element and added to the second element. This step can be repeated any number of times.

Examples:

Input: arr[]={1, 2, 3}
Output: 0
Explanation: Choosing 1 and 3 for updating the array, 3-1=2 and 1+1=2. So the updated array becomes arr[]={2, 2, 2}. Minimum possible sum of the absolute difference of pairs is 0+0+0=0.

Input: arr[]={0, 1, 1, 0}
Output: 4
Explanation: Choosing any two elements for updation will lead to increase in total sum of absolute differences. So the sum is 1+1+1+1+0+0=4.

Approach: The given problem can be solved based on the following observations:

• To minimize the sum of absolute differences between all the unique pairs, the elements should be as closest as possible.
• To make that, find the sum S and divide sum S by N i.e, val = S/N.
• If val is an integer, then the problem becomes very simple as following the operations all the integers can be converted to X.
• Else, some elements say X will be the integer just less than val, i.e, floor(val) and others will be ceil(val).
• For finding the value of X, use the fact that even after updating the sum of the array will be same. So, use the following equation to find the value of X.

x*(b-1) + N*b – x*b = S

=>  x*b – x + N*b – x*b = S

=>  N*b – x = S

=>  x = N*b – S

• For e.g.

N = 10
arr[] = {8, 3, 6, 11, 5, 2, 1, 7, 10, 4}
Sum of all elements of the array, S=57
So, S/N = 5.7 means if all the elements are converted to 5.7, then the sum of all absolute differences b/w all unique pairs of elements will be minimized i.e, 0.
But converting all elements to 5.7 using the mentioned operation isn’t possible.
So, some elements will be 5 and the others will be 6.

Now, the question is how many elements will be 5. Let’s say x, then (N-x) will be 6 and in all this process sum will be always be conserved.
=> x*5 + (N-x)*6 = 57
=> -x = 57 – 60 (Putting the value of N as 10 and solving the equation)
-x = -3 => x=3
So, the converted array will be {5, 5, 5, 6, 6, 6, 6, 6, 6, 6}

• Now the pairs which will give a difference like 1 are x*(N-x).
• So the total sum of differences will also be x*(N-x).

Follow the steps below to solve the problem:

• Initialize the variable sum as 0 to store the sum of elements in the array arr[].
• Iterate over the range [0, N] using the variable i and perform the following steps:
• Add the value of arr[i] in the variable sum.
• Initialize the variable temp as (float)S/N.
• Set the value of a as the floor value of temp.
• Set the value of b as the ceil value of temp.
• Set the value of x as b*N-sum to store the position where partition will happen.
• Print the value of x*(N-x) as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to calculate the minimum``// sum of differences of pairs``void` `solve(``int` `N, ``int` `arr[])``{``    ``int` `a, b, S = 0, x;``    ``for` `(``int` `i = 0; i < N; i++) {``        ``// Take sum of all elements``        ``S = S + arr[i];``    ``}` `    ``// Store s/n to a temporary float``    ``// variable and typecast``    ``// s/n to get exact float value``    ``float` `temp = (``float``)S / N;` `    ``// take floor value of temp``    ``a = ``floor``(temp);``    ``// take floor value of temp``    ``b = ``ceil``(temp);``    ``// position where partition will happen``    ``x = b * N - S;``    ``// Total sum of differences``    ``cout << x * (N - x);``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 8, 3, 6, 11, 5, 2, 1, 7, 10, 4 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``solve(N, arr);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;` `class` `GFG``{``  ` `  ``// Function to calculate the minimum``// sum of differences of pairs``static` `void` `solve(``int` `N, ``int` `arr[])``{``    ``int` `a, b, S = ``0``, x;``    ``for` `(``int` `i = ``0``; i < N; i++)``    ``{``      ` `        ``// Take sum of all elements``        ``S = S + arr[i];``    ``}` `    ``// Store s/n to a temporary float``    ``// variable and typecast``    ``// s/n to get exact float value``    ``float` `temp =(``float``) S / N;` `    ``// take floor value of temp``    ``a = (``int``) Math.floor(temp);``  ` `    ``// take floor value of temp``    ``b = (``int``)Math.ceil(temp);``  ` `    ``// position where partition will happen``    ``x = b * N - S;``  ` `    ``// Total sum of differences``      ``System.out.println(x * (N - x));``}` `// Driver Code``    ``public` `static` `void` `main (String[] args) {``       ``int` `arr[] = { ``8``, ``3``, ``6``, ``11``, ``5``, ``2``, ``1``, ``7``, ``10``, ``4` `};``    ``int` `N = arr.length;` `    ``solve(N, arr);``    ``}``}` `// This code is contributed by Potta Lokesh`

## Python3

 `# Python program for the above approach``import` `math` `# Function to calculate the minimum``# sum of differences of pairs``def` `solve(N, arr):``    ``a, b, S, x ``=` `0``, ``0``, ``0``, ``0``;``    ``for` `i ``in` `range``(``0``, N, ``1``):` `        ``# Take sum of all elements``        ``S ``=` `S ``+` `arr[i];``    ` `    ``# Store s/n to a temporary float``    ``# variable and typecast``    ``# s/n to get exact float value``    ``temp ``=` `S ``/` `N;` `    ``# take floor value of temp``    ``a ``=` `math.floor(temp);` `    ``# take floor value of temp``    ``b ``=` `math.ceil(temp);` `    ``# position where partition will happen``    ``x ``=` `b ``*` `N ``-` `S;` `    ``# Total sum of differences``    ``print``(x ``*` `(N ``-` `x));` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[ ``8``, ``3``, ``6``, ``11``, ``5``, ``2``, ``1``, ``7``, ``10``, ``4` `];``    ``N ``=` `len``(arr);` `    ``solve(N, arr);` `# This code is contributed by 29AjayKumar`

## C#

 `using` `System;` `public` `class` `GFG {``    ``static` `void` `solve(``int` `N, ``int``[] arr)``    ``{``        ``int`  `b, S = 0, x;``        ``for` `(``int` `i = 0; i < N; i++) {` `            ``// Take sum of all elements``            ``S = S + arr[i];``        ``}` `        ``// Store s/n to a temporary float``        ``// variable and typecast``        ``// s/n to get exact float value``        ``float` `temp = (``float``)S / N;` `        ``// take floor value of temp``        ``b = (``int``)Math.Ceiling(temp);` `        ``// position where partition will happen``        ``x = b * N - S;` `        ``// Total sum of differences``        ``Console.WriteLine(x * (N - x));``    ``}` `    ``// Driver Code``    ``static` `public` `void` `Main()``    ``{``        ``int``[] arr = { 8, 3, 6, 11, 5, 2, 1, 7, 10, 4 };``        ``int` `N = arr.Length;` `        ``solve(N, arr);``    ``}``}` `// This code is contributed by maddler.`

## Javascript

 ``

Output

`21`

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

My Personal Notes arrow_drop_up