Skip to content
Related Articles

Related Articles

Improve Article
Minimum Increment operations to make Array unique
  • Difficulty Level : Medium
  • Last Updated : 31 May, 2021

Given an array A[] of integers. In one move you can choose any element A[i], and increment it by 1. The task is to return the minimum number of moves needed to make every value in the array A[] unique.
Examples: 
 

Input: A[] = [3, 2, 1, 2, 1, 7]
Output: 6
Explanation:  After 6 moves, the array could be 
[3, 4, 1, 2, 5, 7].
It can be shown that it is impossible for the array 
to have all unique values with 5 or less moves.

Input: A[] = [1, 2, 2]
Output: 1
Explanation: After 1 move [2 -> 3], the array could be [1, 2, 3].

 

A simple solution to make each duplicate value unique is to keep incrementing it repeatedly until it is not unique. However, we might do a lot of extra work, if we have an array of all ones.
So, what we can do instead is to evaluate what our increments should be. If for example, we have [1, 1, 1, 3, 5], we don’t need to process all the increments of duplicated 1’s. We could take two ones (taken = [1, 1]) and continue processing. Whenever we find an empty(unused value) place like 2 or 4 we can then recover that our increment will be 2-1, 4-1 respectively.
Thus, we first count the values and for each possible value X in the array: 
 

  • If there are 2 or more values X in A, save the extra duplicated values to increment later.
  • If there are 0 values X in A, then a saved value gets incremented to X.

Below is the implementation of the above approach: 
 

CPP




// C++ Implementation of above approach
#include <bits/stdc++.h>
 
using namespace std;
 
// function to find minimum increment required
int minIncrementForUnique(vector<int> A)
{
 
    // collect frequency of each element
    unordered_map<int, int> mpp;
 
    for(int i:A) mpp[i]++;
 
    // taken is to keep count
    // of duplicate items
    int taken=0, ans=0;
 
    for (int x = 0; x < 100000; x++)
    {
         
        // If number is present
          // multiple times
          if (mpp[x] >= 2){
          taken += mpp[x]-1;
          ans -= x*(mpp[x]-1);
        }
           
          // If there is no x in the array
        else if(taken > 0 and mpp[x] == 0)
        {
            ans += x;
            taken--;
        }
    }
 
    // return answer
    return ans;
}
 
// Driver code
int main()
{
    vector<int> A = {3, 2, 1, 2, 1, 7};
     
    // Function Call
    cout << minIncrementForUnique(A);
     
    return 0;
}
 
// This code is contributed by mohit kumar 29
Java



// Java Implementation of above approach
import java.util.*;
 
class GFG {
 
    // function to find minimum increment required
    static int minIncrementForUnique(int[] A)
    {
        // collect frequency of each element
        TreeMap<Integer, Integer> dict
            = new TreeMap<Integer, Integer>();
        HashSet<Integer> used = new HashSet<Integer>();
 
      // Load Frequency Map (Element -> Count) and Used Set
        for (int i : A) {
            if (dict.containsKey(i))
                dict.put(i, dict.get(i) + 1);
            else {
                dict.put(i, 1);
                used.add(i);
            }
        }
 
        int maxUsed = 0; // Works for +ve numbers
        int ans = 0;
 
        for (Map.Entry<Integer, Integer> entry :
             dict.entrySet()) {
 
            int value = entry.getKey();
            int freq = entry.getValue();
 
            if (freq <= 1) //If not a duplicate, skip
                continue;
 
            int duplicates = freq - 1; // Number of duplicates 1 less than count
           
          // Start with next best option for this duplicate:
          // CurNum + 1 or an earlier maximum number that has been used
            int cur = Math.max(value + 1, maxUsed);
            while (duplicates > 0) {
                if (!used.contains(cur)) {
                    ans += cur - value; // Number of increments = Available Spot - Duplicate Value
                    used.add(cur);
                    duplicates--;
                    maxUsed = cur;
                }
                cur++;
            }
        }
 
        // return answer
        return ans;
    }
 
    // Driver code
 
    public static void main(String[] args)
    {
        int[] A = { 3, 2, 1, 2, 1, 2, 6, 7 };
        System.out.print(minIncrementForUnique(A));
    }
}
 
// This code is contributed by Aditya
Python3



# Python3 Implementation of above approach
import collections
 
# function to find minimum increment required
def minIncrementForUnique(A):
 
    # collect frequency of each element
    count = collections.Counter(A)
 
    # array of unique values taken
    taken = []
 
    ans = 0
 
    for x in range(100000):
        if count[x] >= 2:
            taken.extend([x] * (count[x] - 1))
        elif taken and count[x] == 0:
            ans += x - taken.pop()
 
    # return answer
    return ans
 
# Driver code
A = [3, 2, 1, 2, 1, 7]
print(minIncrementForUnique(A))
C#



// C# Implementation of above approach
using System;
using System.Collections.Generic;
 
class GFG
{
  
// function to find minimum increment required
static int minIncrementForUnique(int []A)
{
  
    // collect frequency of each element
    Dictionary<int,int> mpp = new Dictionary<int,int>();
  
    foreach(int i in A)
    {
        if(mpp.ContainsKey(i))
            mpp[i] = mpp[i] + 1;
        else
            mpp.Add(i, 1);
    }
  
    // array of unique values taken
    List<int> taken = new List<int>();
  
    int ans = 0;
  
    for (int x = 0; x < 100000; x++)
    {
        if (mpp.ContainsKey(x) && mpp[x] >= 2)
            taken.Add(x * (mpp[x] - 1));
        else if(taken.Count > 0 &&
                ((mpp.ContainsKey(x) &&
                mpp[x] == 0)||!mpp.ContainsKey(x)))
        {
            ans += x - taken[taken.Count - 1];
            taken.RemoveAt(taken.Count - 1);
        }
    }
  
    // return answer
    return ans;
}
  
// Driver code
public static void Main(String[] args)
{
  
    int []A = {3, 2, 1, 2, 1, 7};
      
    Console.Write(minIncrementForUnique(A));
}
}
 
// This code contributed by PrinciRaj1992
Output: 
6
 
Time Complexity: O(N)
 
Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.



My Personal Notes
arrow_drop_up
Next

Making elements distinct in a sorted array by minimum increments
Recommended Articles
Page :
Minimum increment operations to make the array in increasing order
27, Oct 18
Minimum number of increment-other operations to make all array elements equal.
05, Oct 17
Minimum increment or decrement operations required to make the array sorted
15, Oct 19
Minimum increment by k operations to make all elements equal
04, Mar 18
Minimum increment/decrement operations required to make Median as X
02, Jul 20
Minimum range increment operations to Sort an array
03, Dec 18
Minimum number of increment/decrement operations such that array contains all elements from 1 to N
28, Nov 18
Minimum increment/decrement operations required on Array to satisfy given conditions
19, Aug 20
Minimum Increment / decrement to make array elements equal
15, Nov 18
Minimum operations to make XOR of array zero
18, Sep 17
Minimum operations to make GCD of array a multiple of k
07, May 18
Minimum gcd operations to make all array elements one
19, Nov 17
Minimum increment and decrement by K of each pair elements required to make all array elements equal
31, Jan 21
Make all the array elements odd with minimum operations of given type
13, Jan 20
Minimum operations to make counts of remainders same in an array
13, Feb 19
Minimum operations to make all elements equal using the second array
07, May 20
Minimum no. of operations required to make all Array Elements Zero
08, Oct 18
Minimum delete operations to make all elements of array same
09, Dec 16
Minimum number of operations on an array to make all elements 0
05, Feb 19
Minimum pair sum operations to make array each element divisible by 4
12, Jan 18
Minimum operations required to make all Array elements divisible by K
02, Jul 20
Minimum operations required to make all the elements distinct in an array
12, Jul 18
Minimum Cost to make all array elements equal using given operations
22, May 20
Minimum Bitwise OR operations to make any two array elements equal
12, Jul 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Sanjit_Prasad
@Sanjit_Prasad
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox