<p>You are given an integer array <code>nums</code>. In one move, you can pick an index <code>i</code> where <code>0 &lt;= i &lt; nums.length</code> and increment <code>nums[i]</code> by <code>1</code>.</p>

<p>Return <em>the minimum number of moves to make every value in </em><code>nums</code><em> <strong>unique</strong></em>.</p>

<p>The test cases are generated so that the answer fits in a 32-bit integer.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> nums = [1,2,2]
<strong>Output:</strong> 1
<strong>Explanation:</strong> After 1 move, the array could be [1, 2, 3].
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> nums = [3,2,1,2,1,7]
<strong>Output:</strong> 6
<strong>Explanation:</strong> 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.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
	<li><code>0 &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
</ul>

class Solution {
public:
    int minIncrementForUnique(vector<int>& nums) {
        unordered_map<int,int> mp;
        for(int i=0;i<nums.size();i++)
            mp[nums[i]]++;
        priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>> pq;
        for(auto& [k,v]:mp)
            pq.push({k,v});
        int res = 0;
        while(!pq.empty()) {
            auto currNum = pq.top().first;
            auto currCount = pq.top().second;
            pq.pop();
            if(currCount < 2)
                continue;
            if(!pq.empty()) {
                auto nextNum = pq.top().first;
                auto nextCount = pq.top().second;
                auto count = nextNum - currNum - 1;
                if(count > currCount-1) {
                    res += (1+ 1*(currCount-1))*(currCount-1)/2;
                }
                else{
                    pq.pop();
                    res += count == 0 ? currCount-1:(1 + 1*count)*count/2;
                    if(count)
                        res += (currCount-count-1)*( nextNum - currNum);
                    // cout<< "currNum :"　<< currNum << endl;
                    // cout<< "currCount :"　<< currCount << endl;
                    // cout<< "nextNum :"　<< nextNum << endl;
                    // cout<< "nextCount :"　<< nextCount << endl;
                    // cout<< res << endl;
                    pq.push({nextNum,nextCount + (currCount - count-1)});
                }
            }
            else {
                res += (1+ 1*(currCount-1))*(currCount-1)/2;
            }
        }
        return res;
    }
};
// 1 2
// 2 2
// 3 1
// 7 1

// 1 2
// 2 2
// 3 1
// 4 2
// 7 2
// 8 1
89719