241. Different Ways to Add Parentheses

Given a string of numbers and operators, return all possible results from computing all the different possible ways to group numbers and operators. The valid operators are +, - and *.

Example 1:

Input: "2-1-1"
Output: [0, 2]
Explanation: 
((2-1)-1) = 0 
(2-(1-1)) = 2
Example 2:

Input: "2*3-4*5"
Output: [-34, -14, -10, -10, 10]
Explanation: 
(2*(3-(4*5))) = -34 
((2*3)-(4*5)) = -14 
((2*(3-4))*5) = -10 
(2*((3-4)*5)) = -10 
(((2*3)-4)*5) = 10

这题明显是一个divide and conquer题，就是要递归分治。但这里有两个递归的思路，一个是跟着数字走，四个数字变成三个数字，再变成两个数字，以此为基础计算，输出结果大概是对的，但会有重复，比如题干里的第二个例子，2和3先结合，或者4和5先结合，会有重复的考虑，不太好避免。所以第二个划分方法更好，就是从运算符号入手，毕竟，针对所有结果的讨论可以归结到最后是进行哪个符合运算结束的。
代码如下:

class Solution {
public:
    vector<int> diffWaysToCompute(string input) {
        vector<int> res;
        for (int i = 0; i < input.size(); i++) {
            char ch = input[i];
            if (ch == '+' || ch == '-' || ch == '*') {
                vector<int> left = diffWaysToCompute(input.substr(0, i));
                vector<int> right = diffWaysToCompute(input.substr(i + 1, input.size() - i - 1));
                for (int j = 0; j < left.size(); j++) {
                    for (int k = 0; k < right.size(); k++) {
                        if (ch == '+')
                            res.push_back(left[j] + right[k]);
                        else if (ch == '-')
                            res.push_back(left[j] - right[k]);
                        else if (ch == '*')
                            res.push_back(left[j] * right[k]);
                    }
                }
            }
        }
        if (res.size() == 0) res.push_back(stoi(input));
        return res;
    }
};

优化，这里很类似rod cut 那个DP的引入例子，递归可以做，但是会有重复的子问题被多次计算，所以可以试着把计算过的结果存起来。这里引入一个外部的hash table。如下：

class Solution {
private:
    unordered_map<string, vector<int>> hash;
public:
    vector<int> diffWaysToCompute(string input) {
        vector<int> res;
        if (hash.find(input) != hash.end()) return hash[input];
        for (int i = 0; i < input.size(); i++) {
            char ch = input[i];
            if (ch == '+' || ch == '-' || ch == '*') {
                vector<int> left = diffWaysToCompute(input.substr(0, i));
                vector<int> right = diffWaysToCompute(input.substr(i + 1, input.size() - i - 1));
                for (int j = 0; j < left.size(); j++) {
                    for (int k = 0; k < right.size(); k++) {
                        if (ch == '+')
                            res.push_back(left[j] + right[k]);
                        else if (ch == '-')
                            res.push_back(left[j] - right[k]);
                        else if (ch == '*')
                            res.push_back(left[j] * right[k]);
                    }
                }
            }
        }
        if (res.size() == 0) res.push_back(stoi(input));
        hash[input] = res;
        return res;
    }
};