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

Question

我想了解什么是 leetcode 241 的时间复杂度。添加括号的不同方法。我使用了记忆技术。我的朋友在谷歌编码轮中被问到，他无法给出正确的时间和空间复杂度。我在 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.*;

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

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

我发现的一些有用的链接。

https://www.cnblogs.com/yrbbest/p/5006196.html

https://just4once.gitbooks.io/leetcode-notes/content/leetcode/divide-and-conquer/241-different-ways-to-add-parentheses.html

Answer 1

观察

1. 如果表达式由单个数字组成，则有1 放置括号的方式。
2. 如果表达式中只有1 数学运算符，则只有1 可以放置括号以获得相关结果。例如，3 + 4 是 (3 + 4)。
3. 如果表达式中有2 数学运算符，则有2 放置括号的方法。例如，对于3 + 4 - 2，该方法会将+ 的表达式拆分为3 和4 - 2，然后将- 拆分为3 + 4 和2。所以，这是2 方式。
4. 如果表达式中有3 数学运算符，则结果为5。比如1 + 2 - 3 * 4可以拆分为1和2 - 3 * 4、1 + 2和3 * 4、1 + 2 - 3 and 4. As we've learned from 2) and 3), the number of ways is 2+1+2=5种方式。
5. 如果表达式中有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 路数。

如果序列继续，那么它将是42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, ...。如您所见，它呈指数级增长。

这样的数字序列有一个名字，叫做Catalan numbers。

算法应用

您可能已经意识到，即使您获得了由第一个数学运算符拆分的左右子表达式的结果，您的算法也会变成指数级。

因此，如果有 10 数学运算符，那么在计算第一个配置的结果（表达式由第一个数学运算符拆分）后，它们的编号将是 4862。

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