leetcode 241. Different Ways to Add Parentheses-分治算法

原题链接：241. Different Ways to Add Parentheses

【思路-Java、Python】 递归实现

采用分治算法，分治算法的基本思想是将一个规模为N的问题分解为K个规模较小的子问题，这些子问题相互独立且与原问题性质相同，求出子问题的解，就可得到原问题的解。那么针对本题，以操作符为分界，将字符串分解为较小的两个子字符串，然后依次对两个子字符串进行同样的划分，直到字符串中只含有数字。再根据操作符对两端的数字进行相应的运算。

由于原问题和子问题中操作符不止有一个，那么就需要在原问题和子问题中循环找到这个操作符，进行同样的划分：

public class Solution {
    public List<Integer> diffWaysToCompute(String input) {
        List<Integer> res = new ArrayList<Integer>();
        for (int i=0; i<input.length(); i++) {
            char ch = input.charAt(i);
            if (ch == '+' || ch == '-' || ch == '*') {
                List<Integer> left = diffWaysToCompute(input.substring(0,i));
                List<Integer> right = diffWaysToCompute(input.substring(i+1,input.length()));
                for (int l : left) {
                    for (int r : right) {
                        switch(ch) {
                        case '+' :
                            res.add(l+r);
                            break;
                        case '-' :
                            res.add(l-r);
                            break;
                        case '*' :
                            res.add(l*r);
                            break;
                        }
                    }
                }
            }
        }
        if (res.size() == 0) res.add(Integer.valueOf(input));
        return res;
    }
}

24 / 24  test cases passed. Runtime: 8 ms  Your runtime beats 38.13% of javasubmissions.

显然上述解法对子问题存在重复计算，效率不高，这里采用备忘录的自顶向下法，将子问题的计算结果保存下来，下次遇到同样的子问题就直接从备忘录中取出，而免去繁琐的计算，具体的做法是新建一个 hashmap，将子字符串放入 hashmap 中，对应的计算结果放入 value 中：

public class Solution {
    private HashMap<String, List<Integer>> hm = new HashMap<String, List<Integer>>();
    public List<Integer> diffWaysToCompute(String input) {
        if(hm.containsKey(input)) return hm.get(input);
        List<Integer> res = new ArrayList<Integer>();
        for (int i=0; i<input.length(); i++) {
            char ch = input.charAt(i);
            if (ch=='+' || ch=='-' || ch=='*')
                for (Integer l : diffWaysToCompute(input.substring(0,i)))
                    for (Integer r : diffWaysToCompute(input.substring(i+1,input.length())))
                        if(ch=='+') res.add(l+r);
                        else if (ch == '-') res.add(l-r);
                        else res.add(l*r);
        }
        if (res.size() == 0) res.add(Integer.valueOf(input));
        hm.put(input, res);
        return res;
    }
}

24 / 24  test cases passed. Runtime: 3 ms  Your runtime beats 89.71% of javasubmissions.

class Solution(object):
    def diffWaysToCompute(self, input):
        """
        :type input: str
        :rtype: List[int]
        """
        def dfs(s, cache) :
            ops = {'+':lambda x,y:x+y, '-':lambda x,y:x-y, '*':lambda x,y:x*y}
            if not cache.has_key(s) :
                ret = []
                for k, v in enumerate(s) :
                    if v in '+-*' :
                        for left in dfs(s[:k], cache) :
                            for right in dfs(s[k+1:], cache) :
                                ret.append(ops[v](left,right))
                if not ret :
                    ret.append(int(s))
                cache[s] = ret
            return cache[s]
        return dfs(input, {})

24 / 24  test cases passed. Runtime: 60 ms  Your runtime beats 68.31% of pythonsubmissions.