java – 如何计算此解决方案的时间和空间复杂度？

我正在解决leetcode上的this问题.无法弄清楚我的解决方案的时间和空间复杂性.

特别是,在我们有FOR循环的情况下,我无法理解如何应用Master Theorem.什么是a和b在这里？由于输入分为多次并且针对不同大小的子问题.另一个复杂因素是记忆.

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;
    }
}

我正在寻找解释如何计算时间复杂度的解释,而不仅仅是答案.最好是你可以解释有没有记忆的复杂性.谢谢！

解决方法:

算法的时间复杂度等于包含正确匹配的n对括号的表达式的数量.

它被称为加泰罗尼亚数字,它等于C(2 * n,n)/(n 1)=(2 * n)！ /((n 1)！* 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)

而且你知道,它和你的算法时间复杂度方程一样！

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)

该算法的存储器复杂度可以与其时间复杂度一样大,因为结果ArrayList的元素数量可能很大.因此,在最坏情况下,内存和时间复杂度将是第n个加泰罗尼亚数字.

资源：
https://en.wikipedia.org/wiki/Catalan_number

标签：java,algorithm,time-complexity,recursion,divide-and-conquer
来源： https://codeday.me/bug/20190710/1424490.html