LeetCode 241 - Different Ways to Add Parentheses

LeetCode 241 - Different Ways to Add Parentheses

LeetCode 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”.

((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]

我的解答

这道题也是在分治算法分类中找的，属于Medium难度。

划分括号这个问题很经典，我曾经在离散数学课中接触过。只是那时候问题是求(x~0~ x~1~ x~2~ … x~n~)有多少种划分括号的方式，思路是考虑最后一次运算符的位置。这个位置可以是第一个运算符和最后一个运算符中任何一个，因此我们要遍历一下所有运算符。对于每个运算符，我们再递归地求解这个运算符左边和右边式子的可能数量，二者相乘，即当前运算符位置所具有的总可能数。将所有运算符可能数相加，就可以得到原式具有的所有括号划分的可能。

这个问题其实算是卡特兰数的一个特例。

对于这里的问题，我们只需要对上述问题解答略作修改：将求解子式的可能数改成求解子式可能的结果的集合。

关于时间复杂度，如果假设有n个数字的输入，A(n)为结果的集合大小，T(n)为对应的操作数量，有：

$A(n)=\sum_{i=1}^{n-1}A(i)A(n-i)$

$T(n)=\sum_{i=1}^{n-1} (T(i)+T(n-i)+A(i)A(n-i))$

我不知道怎么证明这里的时间复杂度，如果有心人看到可以讨论一下。不过根据卡特兰数的通项公式$\binom{2n}{n}/{(n+1)}$ ，T(n)至少不是多项式级的。

class Solution {
public:

    vector<int> diffWaysToCompute_helper(string input)
    {
        vector<int>re;//返回结果
        vector<int>operand;//数
        vector<char>binop;//运算符
        vector<int>binop_pos;//运算符所在原字符串的位置
        int tmp=0;
        for(int i=0;i<input.size();i++)
        {
            if(isdigit(input[i]))
            {
                tmp=tmp*10+(input[i]-'0');
            }
            else
            {
                operand.push_back(tmp);
                tmp=0;
                binop.push_back(input[i]);
                binop_pos.push_back(i);
            }
        }
        operand.push_back(tmp);
        if(binop.size()==0)
        {
            return {operand[0]};
        }

        if(binop.size()==1)
        {
            if(binop[0]=='+')
            {
                return {operand[0]+operand[1]};
            }
            else if(binop[0]=='-')
            {
                return {operand[0]-operand[1]};
            }
            else
            {
                return {operand[0]*operand[1]};
            }
        }

        for(int i=0;i<binop.size();i++)
        {
            auto left=diffWaysToCompute_helper(input.substr(0,binop_pos[i]));
            auto right=diffWaysToCompute_helper(input.substr(binop_pos[i]+1,input.size()-binop_pos[i]-1));
            for(auto l:left)
            {
                for(auto r:right)
                {
                    if(binop[i]=='+')
                    {
                        re.push_back(l+r);
                    }
                    else if(binop[i]=='-')
                    {
                        re.push_back(l-r);
                    }
                    else
                    {
                        re.push_back(l*r);
                    }
                }
            }
        }

        return re;
    }

    vector<int> diffWaysToCompute(string input)
    {
        auto r=diffWaysToCompute_helper(input);
        sort(r.begin(),r.end());
        return r;
    }


};

​
​
​