Java LeetCode 241的时间和空间复杂度是多少。添加括号的不同方法？

我试图理解LeetCode241的时间复杂性是什么。添加括号的不同方法。我使用了记忆技术。我的朋友在谷歌编码回合中被问到，他不能给出正确的时间和空间复杂度。我在Leetcode中发现了同样的问题

问题: 给定一个数字和运算符字符串，返回计算所有可能的数字和运算符分组方法的所有可能结果。有效运算符为+、-和*

例1：

输入：“2-1-1”

输出：[0,2]

说明：

（（2-1）-1）=0

（2-（1-1））=2

例2：

输入：“2*3-4*5”

输出：[-34，-14，-10，-10,10]

说明：

（2*（3-（4*5））=-34

（（23）-（45））=-14

（（2*（3-4））*5）=-10

（2*（（3-4）*5））=-10

（（2*3）-4*5）=10

代码：

import java.util.*；
类解决方案{
Map Map=newhashmap（）；
公共列表diffWaysToCompute（字符串输入）{
if（映射容器（输入））{
返回map.get（输入）；
}
列表结果=新建ArrayList（）；
int length=input.length（）；
for（int i=0；i结果中未添加任何内容，因此添加3。。。
if（result.size（）==0）{
结果.add（Integer.valueOf（input））；
}
返回结果；
}
专用布尔等运算符（字符）{
返回字符=='-'| |字符=='*'| |字符=='+'；
}
私有void计算和存储结果（字符串输入、列表结果、int i、列表部分1结果、列表部分2结果）{
for（整数p1:part1Result）{
for（整数p2:part2Result）{
int c=0；
开关（输入字符（i））{
格“+”：
c=p1+p2；
打破
案例'-'：
c=p1-p2；
打破
案例“*”：
c=p1*p2；
打破
}
结果.添加（c）；
}
}
}
}

我在很多网站上都找不到很好的解释 这就是递归树的样子：使用的技术是带记忆的分而治之。

我找到了一些有用的链接

观察

如果表达式由单个数字组成，则有

1

方法放置括号

如果表达式中只有

1

数学运算符，那么只有

1

方法可以放置括号以获得相关结果。例如，对于

3+4

，它是

（3+4）

如果表达式中有

2

数学运算符，则有

2

种放置括号的方法。例如，对于

3+4-2

，该方法将表达式按

+

拆分为

3

和

4-2

，然后按

-

拆分为

3+4

和

2

。所以，这是两种方式

如果表达式中有

3

数学运算符，则为

5

结果。例如，

1+2-3*4

可以分为

1

和

2-3*4

，

1+2

和

3*4

，

1+2-3和
4
。正如我们从2）和3）中了解到的，方法的数量是
2+1+2=5`ways

如果表达式中有

4

数学运算符，则为

14

结果。例如，

1+2-3*4+5

可以分为

1

和

2-3*4+5

，

1+2

和

3*4+5

，

1+2-3

和

4+5

，

1+2-3*4

和

5

。正如我们从2）、3）和4）中了解到的，方法的数量相应地是

5+2+2+5=14

如果序列继续，则它将是

421324294193048621679658786208012742900，…

。如你所见，它呈指数增长

这样的数字序列有一个名称，称为

应用你的算法 正如您可能已经意识到的那样，即使在获得由第一个数学运算符拆分的左、右子表达式的结果后，您的算法也将变成指数型

因此，如果存在

10个

数学运算符，则在计算第一个配置的结果（表达式被第一个数学运算符拆分）后，它们的编号将为

4862

因此，不仅时间复杂度是指数级的，而且空间复杂度也是指数级的，因为您将所有结果保存在一个列表中

import java.util.*;

class Solution {
    Map<String, List<Integer>> map = new HashMap<>(); 
    public List<Integer> diffWaysToCompute(String input) {
        if(map.containsKey(input)) {
            return map.get(input);
        }
        
        List<Integer> result = new ArrayList<>();
        int length = input.length();
        
        for(int i = 0; i< length; i++) {
            char character = input.charAt(i);
            if(isOperator(character)) {
                String part1 = input.substring(0, i);
                String part2 = input.substring(i + 1);
                List<Integer> part1Result = diffWaysToCompute(part1);
                List<Integer> part2Result = diffWaysToCompute(part2);
                computeAndStoreResult(input, result, i, part1Result, part2Result);
        
            }
        }
        //store in map...
        map.put(input, result);
        //this is when only one input is present. 
        // input 3 ==> nothing is added in result so add 3 ...
        if(result.size() == 0) {
            result.add(Integer.valueOf(input));
        }
        return result;
    }
    
    private boolean isOperator(char character) {
        return character == '-' || character == '*' || character == '+';
    }
    
    private void computeAndStoreResult(String input, List<Integer> result, int i, List<Integer> part1Result, List<Integer> part2Result) {
        for(Integer p1 : part1Result) {
            for(Integer p2 : part2Result) {
                int c= 0;
                switch (input.charAt(i)) {
                    case '+':
                        c = p1+p2;
                        break;
                    case '-':
                        c = p1-p2;
                        break;
                    case '*':
                        c = p1*p2;
                        break;
                }
                result.add(c);
            }
        }
    }
}