0322-2020-LEETCODE-945-使数组唯一的最小增量(排序/计数排序/线性探测+路径压缩)

参考学习来源
作者：sweetiee
链接：https://leetcode-cn.com/problems/minimum-increment-to-make-array-unique/solution/ji-shu-onxian-xing-tan-ce-fa-onpai-xu-onlogn-yi-ya/

public int minIncrementForUnique(int[] A) {
        if (A.length == 0){
            return 0;
        }
        Arrays.sort(A);
        int count = 0;
        for (int i = 1; i < A.length; i++) {
            if (A[i] <= A[i - 1]){
                int pre = A[i];
                A[i] = A[i - 1] + 1;
                count += A[i] - pre;
            }
        }
        return count;
    }
    public int minIncrementForUnique1(int[] A) {
        if (A.length == 0){
            return 0;
        }
        System.out.println(Arrays.toString(A));
        int[] arr = new int[40000];
        int sortIndex = 0;
        for (int i = 0; i < A.length; i++) {
            arr[A[i]]++;
        }
        for (int i = 0; i < 40000; i++) {
            while (arr[i] > 0){
                A[sortIndex++] = i;
                arr[i]--;
            }
        }
        System.out.println(Arrays.toString(A));
        int count = 0;
        for (int i = 1; i < A.length; i++) {
            if (A[i] <= A[i - 1]){
                int pre = A[i];
                A[i] = A[i - 1] + 1;
                count += A[i] - pre;
            }
        }
        return count;
    }

    public int minIncrementForUnique2(int[] A) {
        // counter数组统计每个数字的个数。
        //（这里为了防止下面遍历counter的时候每次都走到40000，所以设置了一个max，这个数据量不设也行，再额外设置min也行）
        int[] counter = new int[40000];
        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;
    }






    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;
    }