[LeetCode] (medium) 241. Different Ways to Add Parentheses

https://leetcode.com/problems/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

---

 一开始想用DFS的方法，按照前缀长度来搜索，但是发现前缀中本身也会遇到划分的子问题，于是想到可以使用分治法，以每个符号作为分隔符。

注意到可能存在负数的情况（虽然我不知道样例里有没有考虑这个，但是处理了），即1*2- -3+4的情况，一开始考虑只将第一个‘-’处理成减号号，将第二个‘-’和后面的数字绑定成负号，但是这样就忽视了-(3+4)的可能性，因此两者都要进行分割。

就很自然的想到补足一个运算的单位元上去，但是*和+-的单位元又是不同的，因此具体该补足什么也需要在运算过程中处理。

这些子问题的递归终止条件是遇到无运算符的字符串，很显然如果不做处理的话在最后str2int的步骤下会有很多重复运算，因此在最初先计算好每一个数字的值。更进一步地想，可以对每一个子问题进行记录，只是会花费很多空间。

class Solution {
public:
    
    vector<int> diffWaysToCompute(string input) {
        // static int fast_io = []() { std::ios::sync_with_stdio(false); cin.tie(nullptr); return 0; }();
        input.push_back('+');
        
        // vector<vector<int>> str2int(input.size(), vector<int>(input.size()));
        
        vector<vector<vector<int>>> memo(input.size(), vector<vector<int>>(input.size(), vector<int>()));
        
        int st = 0;
        
        for(int ed = 0; ed < input.size(); ++ed){
            if(input[ed] == '+' || input[ed] == '*' || input[ed] == '-'){
                if(st > ed-1) continue;
                // int tem = str_2_int(input, st, ed-1);
                // str2int[st][ed-1] = tem;
                // st = ed+1;
                
                memo[st][ed-1].push_back(str_2_int(input, st, ed-1));
                st = ed+1;
            }
        }
        
        return divide_solve(input, 0, input.size()-2, memo);
    }
    
    // vector<int> divide_solve(string &input, int st, int ed, 
    //                          vector<vector<int>> &str2int, vector<vector<vector<int>>> &memo){
    vector<int> divide_solve(string &input, int st, int ed, vector<vector<vector<int>>> &memo){
        vector<int> result;
        if(st > ed) return result; // 处理负号的情况
        
        if(!memo[st][ed].empty()) return memo[st][ed];
        
        for(int i = st+1; i <= ed; ++i){
            if(input[i] == '*'){
                vector<int> tem1 = divide_solve(input, st, i-1, memo);
                vector<int> tem2 = divide_solve(input, i+1, ed, memo);
                if(tem1.empty()) tem1.push_back(1);
                if(tem2.empty()) tem2.push_back(1);
                for(int t1 : tem1){
                    for(int t2 : tem2){
                        result.push_back(t1*t2);
                    }
                }
            }else if(input[i] == '+'){
                vector<int> tem1 = divide_solve(input, st, i-1, memo);
                vector<int> tem2 = divide_solve(input, i+1, ed, memo);
                if(tem1.empty()) tem1.push_back(0);
                if(tem2.empty()) tem2.push_back(0);
                for(int t1 : tem1){
                    for(int t2 : tem2){
                        result.push_back(t1+t2);
                    }
                }
            }else if(input[i] == '-'){
                vector<int> tem1 = divide_solve(input, st, i-1, memo);
                vector<int> tem2 = divide_solve(input, i+1, ed, memo);
                if(tem1.empty()) tem1.push_back(0);
                if(tem2.empty()) tem2.push_back(0);
                for(int t1 : tem1){
                    for(int t2 : tem2){
                        result.push_back(t1-t2);
                    }
                }
            }
        }
        // if(result.empty()){
        //     result.push_back(str2int[st][ed]);
        // }
        memo[st][ed] = result;
        return result;
    }
    
    int str_2_int(string &str, int st, int ed){
        bool neg = false;
        if(str[st] == '-'){
            neg = true;
            ++st;
        }
        int result = 0;
        for(; st <= ed; ++st){
            result = result*10 + str[st]-'0';
        }
        return result;
    }
};