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;



    }
}