LeetCode OJ 之 Different Ways to Add Parentheses（增加括号的不同方法）

最新推荐文章于 2019-02-28 00:24:09 发布

思翊

最新推荐文章于 2019-02-28 00:24:09 发布

阅读量3.4k

点赞数

分类专栏： Leetcode OJ

本文链接：https://blog.csdn.net/u012243115/article/details/47100287

版权

Leetcode OJ 专栏收录该内容

199 篇文章 2 订阅

订阅专栏

题目：

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：

class Solution {
public:
    vector<int> diffWaysToCompute(string input) 
    {
        int len = input.size();
        vector<int> result;
        for(int i = 0 ; i < len ; i++)
        {
            char c = input[i];
            //功能：如果参数是除字母，数字和空格外可打印字符，函数返回非零值，否则返回零值。
            //在这里表示if(c == '+' || c == '-' || c == '*')
            if(ispunct(c))
            {
                vector<int> leftResult = diffWaysToCompute(input.substr(0 , i));
                vector<int> rightResult = diffWaysToCompute(input.substr(i+1));
                for(int j = 0 ; j < leftResult.size() ; j++)
                {
                    for(int k = 0 ; k < rightResult.size() ; k++)
                    {
                        switch(c)
                        {
                            case '+':
                                result.push_back(leftResult[j] + rightResult[k]);
                                break;
                            case '-':
                                result.push_back(leftResult[j] - rightResult[k]);
                                break;
                            case '*':
                                result.push_back(leftResult[j] * rightResult[k]);
                                break;
                            default:
                                break;
                        }
                    }
                }
            }
            
        }
        if(result.empty())
            result.push_back(stoi(input));
        return result;
    }
};

显然上面一种方法对于子问题重复计算了，效率不高。这里可以采用带备忘录的自顶向下法。即如果子问题的结果计算过就把它保存下来，下次需要用时直接取出。如果没有计算过再重新计算。

代码2：

class Solution {
public:
    vector<int> diffWaysToCompute(string input) 
    {
        unordered_map<string , vector<int> > dpmap; //保存计算过的结果
        return diffWaysToCompute(input , dpmap);
    }
    vector<int> diffWaysToCompute(string input , unordered_map<string , vector<int> > &dpmap)
    {
        int len = input.size();
        vector<int> result;
        for(int i = 0 ; i < len ; i++)
        {
            char c = input[i];
            if(c == '+' || c == '-' || c == '*')
            {
                string leftStr = input.substr(0 , i);
                string rightStr = input.substr(i + 1);
                vector<int> leftResult;
                vector<int> rightResult;
                
                if(dpmap.find(leftStr) != dpmap.end())
                    leftResult = dpmap[leftStr];
                else
                    leftResult = diffWaysToCompute(leftStr , dpmap);
                if(dpmap.find(rightStr) != dpmap.end())
                    rightResult = dpmap[rightStr];
                else
                    rightResult = diffWaysToCompute(rightStr , dpmap);
                    

                for(int j = 0 ; j < leftResult.size() ; j++)
                {
                    for(int k = 0 ; k < rightResult.size() ; k++)
                    {
                        switch(c)
                        {
                            case '+':
                                result.push_back(leftResult[j] + rightResult[k]);
                                break;
                            case '-':
                                result.push_back(leftResult[j] - rightResult[k]);
                                break;
                            case '*':
                                result.push_back(leftResult[j] * rightResult[k]);
                                break;
                            default:
                                break;
                        }
                    }
                }
            }
            
        }
        if(result.empty())
            result.push_back(stoi(input));
        dpmap[input] = result;      //把计算过的结果加入哈希表
        return result;
    }
};