[Leedcode][JAVA]第[945]题

【问题描述】

给定整数数组 A，每次 move 操作将会选择任意 A[i]，并将其递增 1。返回使 A 中的每个值都是唯一的最少操作次数。示例 1:输入：[1,2,2]
输出：1
解释：经过一次 move 操作，数组将变为 [1, 2, 3]。
示例 2:输入：[3,2,1,2,1,7]
输出：6
解释：经过 6 次 move 操作，数组将变为 [3, 4, 1, 2, 5, 7]。
可以看出 5 次或 5 次以下的 move 操作是不能让数组的每个值唯一的。
提示：0 <= A.length <= 40000
0 <= A[i] < 40000

【解答思路】

1. 排序 O(NlogN)

先排序，再依次遍历数组元素，若当前元素小于等于它前一个元素，则将其变为前一个数+1。

class Solution {public int minIncrementForUnique(int[] A) {// 先排序Arrays.sort(A);int move = 0;// 遍历数组，若当前元素小于等于它的前一个元素，则将其变为前一个数+1for (int i = 1; i < A.length; i++) {if (A[i] <= A[i - 1]) {int pre = A[i];A[i] = A[i - 1] + 1;move += A[i] - pre;}}return move;}}

2. 注意最后一个的推导计数排序 O(N)

class Solution {public int minIncrementForUnique(int[] A) {// counter数组统计每个数字的个数。//（这里为了防止下面遍历counter的时候每次都走到40000，所以设置了一个max，这个数据量不设也行，再额外设置min也行）int[] counter = new int[40001];int max = -1;for (int num: A) {counter[num]++;max = Math.max(max, num);}// 遍历counter数组，若当前数字的个数cnt大于1个，则只留下1个，其他的cnt-1个后移int move = 0;for (int num = 0; num <= max; num++) {if (counter[num] > 1) {int d = counter[num] - 1;move += d;counter[num + 1] += d;}}// 最后, counter[max+1]里可能会有从counter[max]后移过来的，counter[max+1]里只留下1个，其它的d个后移。// 设 max+1 = x，那么后面的d个数就是[x+1,x+2,x+3,...,x+d],// 因此操作次数是[1,2,3,...,d],用求和公式求和。int d = counter[max + 1] - 1;move += (1 + d) * d / 2;return move;}
}

3. 线性探测法（含路径压缩） O(N) 神仙解法

把原数组映射到一个地址不冲突的区域，和解决hash冲突的线性探测法比较相似
直接线性探测可能会由于冲突导致反复探测耗时太长 -> 考虑探测的过程中进行路径压缩
经过某条路径最终探测到一个空位置x后，将这条路径上的值都变成空位置所在的下标x，那么假如下次探测的点又是这条路径上的点，则可以直接跳转到这次探测到的空位置x，从x开始继续探测。

下面用样例2：[3, 2, 1, 2, 1, 7]，来模拟一遍线性探测的过程。

模拟的过程中用int move来记录操作数（即要求的增量数）。

step1: 插入3：

因为3的位置是空的，所以直接放入3即可。（此时数组变成了上图，红色表示本次的更改）

move = 0 保持不变;

step2: 插入2：

因为2的位置是空的，所以直接放入2即可。（此时数组变成了上图，红色表示本次的更改）

move = 0 保持不变;

step3: 插入1：

因为1的位置是空的，所以直接放入1即可。（此时数组变成了上图，红色表示本次的更改）

move = 0 保持不变;

step4: 插入2：

此时我们发现2的位置已经有值了，于是继续向后探测，直到找到空位4，于是2映射到了4。

⚠️并且！！我们要对刚刚走过的路径2->3->4进行压缩，即将他们的值都设置为本次探测到的空位4(那么下次探测就可以直接从4往后找了～～)。

（此时数组变成了上图，红色表示本次的更改）

move = move + 4 - 2 = 2;

step5: 插入1：

此时我们发现1的位置已经有值了，于是向后探测，探测到了2，发现2的位置也有值了，但是由于2在上次的过程中存了上次的空位4，所以我们直接跳转到4+1即从5开始探测就行了（而不需要重复走一遍2->3->4这条路径喽！），此时我们发现5是个空位，因此将1映射到5，并且对刚刚走过的路径1->2->5进行路径压缩即使其都映射到5！

（此时数组变成了上图，红色表示本次的更改）

move = move + 5 - 1 = 6;

step6: 插入7：

因为7的位置是空的，所以直接放入7即可。（此时数组变成了上图，红色表示本次的更改）

move = 6 保持不变;

以上，最终move为6。

class Solution {int[] pos = new int [80000];public int minIncrementForUnique(int[] A) {Arrays.fill(pos, -1); // -1表示空位int move = 0;// 遍历每个数字a对其寻地址得到位置b, b比a的增量就是操作数。for (int a: A) {int b = findPos(a); move += b - a;}return move;}// 线性探测寻址（含路径压缩）private int findPos(int a) {int b = pos[a];// 如果a对应的位置pos[a]是空位，直接放入即可。if (b == -1) { pos[a] = a;return a;}// 否则向后寻址// 因为pos[a]中标记了上次寻址得到的空位，因此从pos[a]+1开始寻址就行了（不需要从a+1开始）。b = findPos(b + 1); //递归pos[a] = b; // ⚠️寻址后的新空位要重新赋值给pos[a]哦，路径压缩就是体现在这里。return b;}
}

4. 贪心算法时间复杂度：O(Nlog N) 空间复杂度：O(1)

 public int minIncrementForUnique(int[] A) {int len = A.length;if (len == 0) {return 0;}Arrays.sort(A);// 打开调试// System.out.println(Arrays.toString(A));int preNum = A[0];int res = 0;for (int i = 1; i < len; i++) {// preNum + 1 表示当前数「最好」是这个值if (A[i] == preNum + 1) {preNum = A[i];} else if (A[i] > preNum + 1) {// 当前这个数已经足够大，这种情况可以合并到上一个分支preNum = A[i];} else {// A[i] < preNum + 1res += (preNum + 1 - A[i]);preNum++;}}return res;}