Java 如何计算此解决方案的时间和空间复杂性？

我正在解决leetcode上的问题。无法计算出我的解决方案的时间和空间复杂性

特别是，当我们有FOR循环时，我不明白如何在这里应用。这里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;
    }
}

类解决方案{
私有映射缓存=新的HashMap（）；
公共列表diffWaysToCompute（字符串方程）{
if（cache.containsKey（等式））返回cache.get（等式）；
if（！（equation.contains（“+”）| | equation.contains（“-”）| | equation.contains（“*”））返回集合；
列表结果=新建ArrayList（）；
对于（int i=0；i

---

我在寻找如何计算时间复杂度的解释，而不仅仅是答案。最好你能解释一下有无记忆的复杂性。谢谢

T（n）=求和{T（i）+T（n-i）}对于某些索引it（n+1）-T（n）=2T（n）=>T（n）算法的时间复杂度等于包含正确匹配的n对括号的表达式数

T(n) = Sum{T(i) + T(N-i)} for some index i <= 2(T(1) + T(2) + ... + T(n - 1))
=> T(n + 1) - T(n) = 2T(n) => T(n) <= O(3^n) worst case 

它叫做一个加泰罗尼亚数，等于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)

由于
result
ArrayList的元素数量可能很大，因此该算法的内存复杂度可能与时间复杂度一样大。所以在最坏的情况下，内存和时间复杂度将是第n个加泰罗尼亚数

资料来源：
我认为你不能在这里应用主定理。如果你把你的问题分成两个或两个以上完全不相交的子问题，并在最后合并它们的结果，就使用主定理