Encontrar el valor máximo de los mismos clavos de longitud después de martillado

TJKT:

Estoy tratando de resolver este problema:

Dada una matriz de enteros positivos, y un entero Y , se le permite sustituir en la mayoría de los Y matriz de elementos con valores menores. Su objetivo es que el arsenal para acabar con grandes como un subconjunto de valores idénticos como sea posible. Devolver el tamaño de este subgrupo más grande.

La matriz está ordenada originalmente en orden creciente, pero usted no necesita preservar esa propiedad.

Así, por ejemplo, si la matriz es [10,20,20,30,30,30,40,40,40] y Y  = 3, el resultado debería ser 6, porque se puede obtener seis años 30 mediante la sustitución de los tres años 40 con 30 años. Si la matriz es [20,20,20,40,50,50,50,50] y Y  = 2, el resultado debería ser 5, porque se puede conseguir cinco años 20 mediante la sustitución de dos de los años 50 con 20 años.

A continuación se muestra mi solución con O (nlogn) complejidad del tiempo. (Es cierto?) Me pregunto si puedo optimizar aún más esta solución?

Gracias por adelantado.

public class Nails {

    public static int Solutions(int[] A, int Y) {
        int N = A.length;
        TreeMap < Integer, Integer > nailMap = new TreeMap < Integer, Integer > (Collections.reverseOrder());
        for (int i = 0; i < N; i++) {
            if (!nailMap.containsKey(A[i])) {
                nailMap.put(A[i], 1);
            } else {
                nailMap.put(A[i], nailMap.get(A[i]) + 1);
            }
        }
        List < Integer > nums = nailMap.values().stream().collect(Collectors.toList());

        if (nums.size() == 1) {
            return nums.get(0);
        }

        //else
        int max = nums.get(0);
        int longer = 0;
        for (int j = 0; j < nums.size(); j++) {
            int count = 0;
            if (Y < longer) {
                count = Y + nums.get(j);
            } else {
                count = longer + nums.get(j);
            }
            if (max < count) {
                max = count;
            }
            longer += nums.get(j);
        }
        return max;
    }


    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            String[] input = scanner.nextLine().replaceAll("\\[|\\]", "").split(",");
            System.out.println(Arrays.toString(input));
            int[] A = new int[input.length - 1];
            int Y = Integer.parseInt(input[input.length - 1]);
            for (int i = 0; i < input.length; i++) {
                if (i < input.length - 1) {
                    A[i] = Integer.parseInt(input[i]);
                } else {
                    break;
                }
            }
            int result = Solutions(A, Y);
            System.out.println(result);
        }
    }
}

ruakh:

Dado que la matriz está ordenada, para empezar, un razonablemente sencillo O ( n solución) es, para cada valor distinto, para contar cuántos elementos tienen ese valor (por iteración) y cuántos elementos tienen un valor mayor (por sustracción).

public static int doIt(final int[] array, final int y) {
    int best = 0;
    int start = 0;
    while (start < array.length) {
        int end = start;
        while (end < array.length && array[end] == array[start]) {
            ++end;
        }

        // array[start .. (end-1)] is now the subarray consisting of a
        // single value repeated (end-start) times.
        best = Math.max(best, end - start + Math.min(y, array.length - end));

        start = end; // skip to the next distinct value
    }
    assert best >= Math.min(y + 1, array.length); // sanity-check
    return best;
}