Leetcode.945. Array sólo el incremento más pequeño

título

Dada una matriz de enteros A, seleccionar cualquier operación se moverá cada A [i], y en incrementos de su 1.

Un valor de retorno de cada uno de un número mínimo de operaciones es único.

Ejemplo 1:

Entrada: [1,2,2]
de salida: 1
Explicación: Después de una operación de movimiento, la matriz se convierte en [1, 2, 3].
Ejemplo 2:

Entrada: [3,2,1,2,1,7]
de salida: 6
Explicación: después de 6 operación de movimiento, la matriz se convierte en [3, 4, 1, 2, 5, 7].
Lo siguiente puede ser visto cinco veces o cinco veces mueven operación no es posible para cada valor único de la matriz.
consejos:

0 <= a.length <= 40000
0 <= A [i] <40 000

pensamiento

Usando la estrategia codicioso (mejor posición movimiento después de elementos repetitivos, tales como [1, 1, 3], la posición óptima de los elementos duplicado movimiento es 2 en lugar de 4) dentro de un rango de elementos de matriz vacío "ocupación" . En primer lugar, ordenar la matriz, en segundo lugar, los elementos que se repiten de la pila (la pila no puede de hecho) y, finalmente, la pila en el espacio dentro del elemento en una gama de elementos de la matriz, y el número de registros requerida para mover la operación. Para lograr lo siguiente:

class Solution {
public:
    int minIncrementForUnique(vector<int>& A) {
        if(A.empty())
            return 0;

        fastsort(A, 0, A.size()-1);

        stack<int> s;
        int ans=0;
        for(int i=0; i<A.size()-1; i++){
            if(A[i] == A[i+1])
                s.push(A[i+1]);
            else if(A[i+1]-A[i] > 1){
                for(int j=A[i]+1; j<A[i+1]; j++){
                    if(!s.empty()){
                        int v=s.top();
                        s.pop();
                        ans+=j-v;
                    }else
                        break;
                }
            }
        }
        int p=A[A.size()-1]+1;
        while(!s.empty()){//“空隙”放不下，放到最后。
            int v=s.top();
            s.pop();
            ans+=p-v;
            p++;
        }
        return ans;
    }
    void fastsort(vector<int>& A, int lo, int hi){
        if(lo>=hi)
            return;
        int p=partition(A, lo, hi);
        fastsort(A, lo, p-1);
        fastsort(A, p+1, hi);
    }

    int partition(vector<int>& A, int lo, int hi){
        int v=A[lo];
        int i=lo, j=hi+1;
        while(true){
            while(A[++i]<v) if(i==hi) break;
            while(v<A[--j]) if(j==lo) break;
            if(i>=j)    break;
            swap(A[i], A[j]);
        }
        swap(A[lo], A[j]);
        return j;
    }
};