Leetcode945.使数组唯一的最小增量

最先想到Arrays.sort()用法，可以对数组进行排序，这样做测试是正确的，但是超过时间限制

class Solution {
    public int minIncrementForUnique(int[] A) {
       Arrays.sort(A);
        int count = 0;
        for(int i = 1; i < A.length; i++){
            if(A[i] == A[i - 1]){
                A[i--]++;
                Arrays.sort(A);
                count++;
            }
        }
        return count;


    }
}

因此我们不能总是使用Arrays.sort()函数，想到在初始的时候进行排序。然后在循环中，首先判断是否和前一个值是否相等，因为数组是有序数组，所以当自增后出现的情况会有和前一个数相等，小于前一个数和大于后一个数三种情况。如果是相等，则前面是有序的，该数本身需要自++,该该数自加加后，会出现比后一个数大的情况，此时数组不是有序的了，需要进行调整，和后一个换顺序，并且i--（因为两个数发生变化了，较小的数到了前面）。此时这个较小的数会存在两个情况，较小的数小于或等于前面的数，如果小于则自++，同时i--，因为不知道自++后该数的情况，如果是等于前面的数，则自++,在这种情况下，使用的内存是比较少的。需要注意的是在判断和后面数的大小时，先要判断i+1 < length,在判断大小，否则报错，在这个问题上栽了好几次了

class Solution {
    public int minIncrementForUnique(int[] A) {
        Arrays.sort(A);
	        int count = 0;
	        for(int i = 1; i < A.length; i++){
	            if(A[i] == A[i - 1]){
	                
	                A[i]++;
	                count++;
	              
	            }
	            if(A[i] < A[i-1]) {
                	A[i--]++;
	                count++;
	               // continue;
                }
	            if( (i +1) < A.length && (A[i] > A[i + 1] )){
                    int temp  = A[i];
                    A[i] = A[i + 1];
                    A[i + 1] = temp;
                    i--;
                }
	        }
	        return count;


    }
}

用数组【3,2,1,2,1,7,1】进行说明

首先sort后变成了【1，1，1，2，2，3，7】

循环从i = 1 开始，发现 1 =1 ,需要将i =1的数自增，【1，2，1，2，2，3，7】 count =1

此时发现2大于后面的数，交换顺序【1，1，2，2，2，3，7】同时i--

i又从1开始了 发现 1= 1 自增 【1，2，2，2，2，3，7】count = 2

i = 2 发现 i = 2的数和 i= 1的数相等，【1，2，3，2，2，3，7】count = 3

3大于后面的数 交换顺序并i-- 【1，2，2，3，2，3，7】 

i = 2， 和前面的数相等 自增 【1，2，3，3，2，3，7】 count =4

i= 3 发现和i =2 是数相等 自增 【1，2，3，4，2，3，7】coount = 5

发现i = 3的数此时比后面的数大 交换位置并i-- 【1，2，3，2，4，3，7】

i =3 发现比前面的数小 自增并i-- 【1，2，3，3，4，3，7】count  =6

i = 3发现和前面的数相等 自增 【1，2，3，4，4，3，7】count = 7

i = 4发现和前面的数相等 自增【1，2，3，4，5，3，7】count = 8

发现比后面的数大 交换顺序并i--【1，2，3，4，3，5，7】

i= 4 发现比前面的数小 自增并i--【1，2，3，4，4，5，7】count =9

i= 4发现和前面的数相等 自增【1，2，3，4，5，5，7】count =10

i =5 发现和前面的数相等 自增【1，2，3，4，5，6，7】count = 11

i = 6 无操作  共11次

优化 其实sort后A[i] 只可能大于等于A[i -1]，但是自增后会出现A[i] <= A[i-1]的情况，此时A[i-1]之前的是有序数组，将A[i] 变成A[i -1]+1 即可，对每个数这样操作即可，但是我们需要返回自增的次数，因此先保存A[i]的值，和后来A[i]的值进行比较就是move的次数。（即count）。此时不会再有i--的情况发生

class Solution {
    public int minIncrementForUnique(int[] A) {
        Arrays.sort(A);
        int count = 0;
        // 遍历数组，若当前元素小于等于它的前一个元素，则将其变为前一个数+1
        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;



    }
}