Leetcode 241. Different Ways to Add Parentheses

241. Different Ways to Add Parentheses

• Total Accepted: 27446
• Total Submissions: 72350
• Difficulty: Medium

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".

((2-1)-1) = 0
(2-(1-1)) = 2

Output: [0, 2]

Example 2

Input: "2*3-4*5"

(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

Output: [-34, -14, -10, -10, 10]

思路：分治。

每个递归这么写：

1. 找到当前字符串的一个符号就分治，left保留符号左边的字符串所能产生的算术值，right保留符号右边所能产生的算术值，再根据符号运算left.size()*right.size()次，得到当前字符串所能产生的所有值，返回结果。

2. 没有找到符号，意味着当前字符串是数值，转换为数值即可。

代码：

没有优化过的：

class Solution {
public:
    vector<int> diffWaysToCompute(string input) {//返回包含当前字符串input所能产生的所有值的vector
        vector<int> left,right,res;
        for(int i=0;i<input.size();i++){
            if(input[i]=='+'||input[i]=='-'||input[i]=='*'){
                left=diffWaysToCompute(input.substr(0,i));
                right=diffWaysToCompute(input.substr(i+1));
                if(input[i]=='+'){
                    for(auto lnum:left){
                       for(auto rnum:right){
                            res.push_back(lnum+rnum);
                        }
                    }
                    continue;
                }
                if(input[i]=='-'){
                     for(auto lnum:left){
                       for(auto rnum:right){
                            res.push_back(lnum-rnum);
                        }
                    }
                    continue;
                }
                if(input[i]=='*'){
                    for(auto lnum:left){
                       for(auto rnum:right){
                            res.push_back(lnum*rnum);
                        }
                    }
                    continue;
                }
            }
        }
        if(!res.size()){
            int num=0;
            for(int i=0;i<input.size();i++){
                num*=10;
                num+=input[i]-'0';
            }
            res.push_back(num);
        }
        return res;
    }
};

用unordered_map解决重叠子问题，使用了ispunct函数判断是否为符号，使用了stoi函数直接将字符串转换为数字：

class Solution {
public:
    unordered_map<string,vector<int> > hashtable;
    vector<int> diffWaysToCompute(string input) {//返回包含当前字符串input所能产生的所有值的vector
        vector<int> left,right,res;
        for(int i=0;i<input.size();i++){
            if(ispunct(input[i])){
                char c=input[i];
                if(hashtable.find(input.substr(0,i))!=hashtable.end()) left=hashtable[input.substr(0,i)];
                else left=diffWaysToCompute(input.substr(0,i));
                if(hashtable.find(input.substr(i+1))!=hashtable.end()) left=hashtable[input.substr(i+1)];
                else right=diffWaysToCompute(input.substr(i+1));
                for(auto lnum:left){
                   for(auto rnum:right){
                        res.push_back(c=='+'?lnum+rnum: c=='-'?lnum-rnum:lnum*rnum);
                    }
                }
            }
        }
        return res.size()?res:vector<int>{stoi(input)};
    }
};