# Minimum increments done in Array such that arr[i] can make all other elements equal

• Difficulty Level : Hard
• Last Updated : 24 Dec, 2021

Given an array arr[] of N size, the task is to find the minimum increment required to elements in the array such that if any element says arr[i] is distributed among the others make N – 1 element equal.

Examples:

Input: arr[] = {0, 0, 3}, N = 3
Output: 3
Explanation: Increments can be done in the following way:

• Increment element at index 0 by 1, so arr[] becomes {1, 0, 3}
• Increment element at index 1 by 2. so arr[] becomes {1, 2, 3}

Now, if any element is chosen and distributed in others, makes all N – 1 elements equal.

Lets say,

• choose 1, add it to 2, so N – 1 elements become {3, 3}
• choose 2, add it to 1, so N – 1 elements become {3, 3}
• choose 3, add 2 of 3 to 1 and add 1 of 3 to 2, so N – 1 elements become {3, 3}

So, total increments = (1 + 2) = 3

Input: arr[] = {4, 3, 1, 6}, N = 4
Output:  4

Approach: The idea to solve this problem is based on the observation that if (N-1)*mx where mx is the maximum element of the array is greater than the sum of the array then the answer would be simply (N-1)*mx – sum. Else if (N-1)*mx is less or equal to sum then take a temporary variable say temp assign it with sum / N – 1. If sum mod N -1 is not equal to 0 increment temp by 1 and take a counter to say count, where count is the difference of temp and mx. Update ans = (count + mx) * (N – 1) and increment sum by count.If sum is equal to (N-1)*mx return count, else return count incremented with the difference of (N-1)*mx and sum. Follow the steps below to solve the problem:

• Initialize the variables mx and sum as 0 to find the sum and the maximum element of the array.
• Iterate over the range [0, N) using the variable i and perform the following tasks:
• Update the value of mx as the maximum of mx or arr[i] and add the value of arr[i] to the variable sum.
• Initialize the variable ans as (N-1)*mx.
• If ans is greater than sum then return ans-sum as the answer.
• Else, initialize the variable temp as sum/(N-1) + sum%(N-1).
• Initialize the variable count as temp – mx.
• Set the value of ans as (count + mx)*(N-1).
• Add the value of count to the variable sum.
•  If sum equals ans, then return the value of count as the answer else return count + ans – sum.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find minimum increment``// required to an element to make N-1``// elements equal by distributing``// any element``int` `minIncrement(``int` `arr[], ``int` `N)``{``    ``// Variable for max element``    ``// and sum``    ``int` `mx = 0, sum = 0;``    ``for` `(``int` `i = 0; i < N; i++) {``        ``mx = max(mx, arr[i]);``        ``sum += arr[i];``    ``}` `    ``// Calculate ans``    ``int` `ans = (N - 1) * mx;` `    ``// If ans is greater than sum``    ``// return its difference``    ``if` `(ans > sum) {``        ``return` `(ans - sum);``    ``}` `    ``// If ans is less or equal to sum``    ``else` `{``        ``int` `temp = sum / (N - 1);``        ``if` `(sum % (N - 1) != 0) {``            ``temp++;``        ``}``        ``int` `count = temp - mx;``        ``ans = (count + mx) * (N - 1);``        ``sum += count;` `        ``// If sum is equal to ans``        ``// return the count``        ``if` `(sum == ans) {``            ``return` `count;``        ``}` `        ``// Else return the summation``        ``// of count and difference``        ``// of ans and sum``        ``else` `{``            ``return` `(count + (ans - sum));``        ``}``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 4, 3, 1, 6 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``cout << minIncrement(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``class` `GFG{` `// Function to find minimum increment``// required to an element to make N-1``// elements equal by distributing``// any element``static` `int` `minIncrement(``int` `arr[], ``int` `N)``{``  ` `    ``// Variable for max element``    ``// and sum``    ``int` `mx = ``0``, sum = ``0``;``    ``for` `(``int` `i = ``0``; i < N; i++) {``        ``mx = Math.max(mx, arr[i]);``        ``sum += arr[i];``    ``}` `    ``// Calculate ans``    ``int` `ans = (N - ``1``) * mx;` `    ``// If ans is greater than sum``    ``// return its difference``    ``if` `(ans > sum) {``        ``return` `(ans - sum);``    ``}` `    ``// If ans is less or equal to sum``    ``else` `{``        ``int` `temp = sum / (N - ``1``);``        ``if` `(sum % (N - ``1``) != ``0``) {``            ``temp++;``        ``}``        ``int` `count = temp - mx;``        ``ans = (count + mx) * (N - ``1``);``        ``sum += count;` `        ``// If sum is equal to ans``        ``// return the count``        ``if` `(sum == ans) {``            ``return` `count;``        ``}` `        ``// Else return the summation``        ``// of count and difference``        ``// of ans and sum``        ``else` `{``            ``return` `(count + (ans - sum));``        ``}``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``4``, ``3``, ``1``, ``6` `};``    ``int` `N = arr.length;` `    ``System.out.print(minIncrement(arr, N));` `}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# python program for the above approach` `# Function to find minimum increment``# required to an element to make N-1``# elements equal by distributing``# any element``def` `minIncrement(arr, N):` `        ``# Variable for max element``        ``# and sum``    ``mx ``=` `0``    ``sum` `=` `0``    ``for` `i ``in` `range``(``0``, N):``        ``mx ``=` `max``(mx, arr[i])``        ``sum` `+``=` `arr[i]` `        ``# Calculate ans``    ``ans ``=` `(N ``-` `1``) ``*` `mx` `    ``# If ans is greater than sum``    ``# return its difference``    ``if` `(ans > ``sum``):``        ``return` `(ans ``-` `sum``)` `        ``# If ans is less or equal to sum``    ``else``:``        ``temp ``=` `sum` `/``/` `(N ``-` `1``)``        ``if` `(``sum` `%` `(N ``-` `1``) !``=` `0``):``            ``temp ``+``=` `1` `        ``count ``=` `temp ``-` `mx``        ``ans ``=` `(count ``+` `mx) ``*` `(N ``-` `1``)``        ``sum` `+``=` `count` `        ``# If sum is equal to ans``        ``# return the count``        ``if` `(``sum` `=``=` `ans):``            ``return` `count` `            ``# Else return the summation``            ``# of count and difference``            ``# of ans and sum``        ``else``:``            ``return` `(count ``+` `(ans ``-` `sum``))` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``4``, ``3``, ``1``, ``6``]``    ``N ``=` `len``(arr)` `    ``print``(minIncrement(arr, N))` `    ``# This code is contributed by rakeshsahni`

## C#

 `// C# program for the above approach``using` `System;``class` `GFG {` `// Function to find minimum increment``// required to an element to make N-1``// elements equal by distributing``// any element``static` `int` `minIncrement(``int` `[]arr, ``int` `N)``{``  ` `    ``// Variable for max element``    ``// and sum``    ``int` `mx = 0, sum = 0;``    ``for` `(``int` `i = 0; i < N; i++) {``        ``mx = Math.Max(mx, arr[i]);``        ``sum += arr[i];``    ``}` `    ``// Calculate ans``    ``int` `ans = (N - 1) * mx;` `    ``// If ans is greater than sum``    ``// return its difference``    ``if` `(ans > sum) {``        ``return` `(ans - sum);``    ``}` `    ``// If ans is less or equal to sum``    ``else` `{``        ``int` `temp = sum / (N - 1);``        ``if` `(sum % (N - 1) != 0) {``            ``temp++;``        ``}``        ``int` `count = temp - mx;``        ``ans = (count + mx) * (N - 1);``        ``sum += count;` `        ``// If sum is equal to ans``        ``// return the count``        ``if` `(sum == ans) {``            ``return` `count;``        ``}` `        ``// Else return the summation``        ``// of count and difference``        ``// of ans and sum``        ``else` `{``            ``return` `(count + (ans - sum));``        ``}``    ``}``}` `// Driver Code``public` `static` `void` `Main()``{``    ``int` `[]arr = { 4, 3, 1, 6 };``    ``int` `N = arr.Length;` `    ``Console.Write(minIncrement(arr, N));` `}``}` `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output
`4`

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

My Personal Notes arrow_drop_up