Cómo calcular el tiempo y la complejidad del espacio de esta solución?

John Smith :

Yo soy la solución de este problema en leetcode. No se puede averiguar el tiempo y la complejidad espacio para mi solución.

En particular, no puedo entender cómo aplicar Maestro Teorema aquí por si cuando tenemos bucle FOR. ¿Cuál es ayb aquí? Desde entrada dividida varias veces y para diferentes tamaños de subproblemas. Otra complicación es memoization.

class Solution {
    private Map<String, List<Integer>> cache = new HashMap<>();
    public List<Integer> diffWaysToCompute(String equation) {
        if (cache.containsKey(equation)) return cache.get(equation);
        if (!(equation.contains("+") || equation.contains("-") || equation.contains("*"))) return Collections.singletonList(Integer.valueOf(equation));
        List<Integer> result =  new ArrayList<>();

        for (int i = 0; i < equation.length();i++) {
            char ch = equation.charAt(i);

            if (ch == '+' || ch == '-' || ch == '*') {
                List<Integer> left = diffWaysToCompute(equation.substring(0, i));
                List<Integer> right = diffWaysToCompute(equation.substring(i+1, equation.length()));

                result.addAll(crossCalc(left, right, ch));
            }
        }

        cache.put(equation, result);

        return result;
    }

    private List<Integer> crossCalc(List<Integer> left, List<Integer> rigth, char sign) {
        List<Integer> result = new ArrayList<>();
        for (Integer l : left) {
            for (Integer r : rigth) {
                if (sign == '-') {
                    result.add(l - r);
                } else if (sign == '+') {
                    result.add(l + r);
                } else {
                    result.add(l*r);
                }
            }
        }
        return result;
    }
}

Busco una explicación de cómo calcular complejidad del tiempo, no sólo la respuesta. Preferiblemente si se pudiera explicar la complejidad de ambos con y sin memoization. ¡Gracias!

Erfan Alimohammadi:

La complejidad momento de su algoritmo es igual al número de expresiones que contienen n pares de paréntesis que se corresponden correctamente.

Se llama un número Catalán , y es igual a C (2 * n, n) / (n + 1) = (2 * n)! / ((N + 1)! * N!).

Además, hay una fórmula recursiva para calcular un número catalán:

f(n+1) = f(0)f(n) + f(1)f(n-1) + f(2)f(n-2) + ... + f(n-2)f(2) + f(n-1)f(1) + f(n)f(0)

Y usted sabe, es el mismo que el algoritmo de la ecuación complejidad del tiempo!

T(n+1) = T(0)T(n) + T(1)T(n-1) + T(2)T(n-2) + ... + T(n-2)T(2) + T(n-1)T(1) + T(n)T(0)

La complejidad de este algoritmo de memoria puede ser tan grande como la complejidad del tiempo de ella, porque el número de elementos de resultArrayList puede ser grande. Por lo que en el peor de los casos la memoria y la complejidad del tiempo sería el n-ésimo número catalán.

Fuente: https://en.wikipedia.org/wiki/Catalan_number