C++實現添加括號的不同方式

本篇內容介紹了“C++實現添加括號的不同方式”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

添加括號的不同方式

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

這道題讓給了一個可能含有加減乘的表達式，讓我們在任意位置添加括號，求出所有可能表達式的不同值。這道題乍一看感覺還蠻難的，給人的感覺是既要在不同的位置上加括號，又要計算表達式的值，結果一看還是道 Medium 的題，直接尼克楊問號臉？！遇到了難題不要害怕，從最簡單的例子開始分析，慢慢的找規律，十有八九就會在分析的過程中靈光一現，找到了破題的方法。這道題貌似默認輸入都必須是合法的，雖然題目中沒有明確的指出這一點，所以我們也就不必進行 valid 驗證了。先從最簡單的輸入開始，若 input 是空串，那就返回一個空數組。若 input 是一個數字的話，那么括號加與不加其實都沒啥區別，因為不存在計算，但是需要將字符串轉為整型數，因為返回的是一個整型數組。當然，input 是一個單獨的運算符這種情況是不存在的，因為前面說了這道題默認輸入的合法的。下面來看若 input 是數字和運算符的時候，比如 "1+1" 這種情況，那么加不加括號也沒有任何影響，因為只有一個計算，結果一定是2。再復雜一點的話，比如題目中的例子1，input 是 "2-1-1" 時，就有兩種情況了，(2-1)-1 和 2-(1-1)，由于括號的不同，得到的結果也不同，但如果我們把括號里的東西當作一個黑箱的話，那么其就變為 ()-1  和 2-()，其最終的結果跟括號內可能得到的值是息息相關的，那么再 general 一點，實際上就可以變成 () ? () 這種形式，兩個括號內分別是各自的表達式，最終會分別計算得到兩個整型數組，中間的問號表示運算符，可以是加，減，或乘。那么問題就變成了從兩個數組中任意選兩個數字進行運算，瞬間變成我們會做的題目了有木有？而這種左右兩個括號代表的黑盒子就交給遞歸去計算，像這種分成左右兩坨的 pattern 就是大名鼎鼎的分治法 Divide and Conquer 了，是必須要掌握的一個神器。類似的題目還有之前的那道 Unique Binary Search Trees II 用的方法一樣，用遞歸來解，劃分左右子樹，遞歸構造。

好，繼續來說這道題，我們不用新建遞歸函數，就用其本身來遞歸就行，先建立一個結果 res 數組，然后遍歷 input 中的字符，根據上面的分析，我們希望在每個運算符的地方，將 input 分成左右兩部分，從而扔到遞歸中去計算，從而可以得到兩個整型數組 left 和 right，分別表示作用兩部分各自添加不同的括號所能得到的所有不同的值，此時我們只要分別從兩個數組中取數字進行當前的運算符計算，然后把結果存到 res 中即可。當然，若最終結果 res 中還是空的，那么只有一種情況，input 本身就是一個數字，直接轉為整型存入結果 res 中即可，參見代碼如下：

解法一：

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

我們也可以使用 HashMap 來保存已經計算過的情況，這樣可以減少重復計算，從而提升運算速度，以空間換時間，豈不美哉，參見代碼如下：

解法二：

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

當然，這道題還可以用動態規劃 Dynamic Programming 來做，但明顯沒有分治法來的簡單，但是既然論壇里這么多陳獨秀同學，博主還是要給以足夠的尊重的。這里用一個三維數組 dp，其中 dp[i][j] 表示在第i個數字到第j個數字之間范圍內的子串添加不同括號所能得到的不同值的整型數組，所以是個三位數組，需要注意的是我們需要對 input 字符串進行預處理，將數字跟操作分開，加到一個字符串數組 ops 中，并統計數字的個數 cnt，用這個 cnt 來初始化 dp 數組的大小，并同時要把 dp[i][j] 的數組中都加上第i個數字，通過 ops[i*2] 取得，當然還需要轉為整型數。既然 dp 是個三維數組，那么肯定要用3個 for 循環來更新，這里采用的更新順序跟之前那道 Burst Balloons 是一樣的，都是從小區間往大區間更新，由于小區間之前更新過，所以我們將數字分為兩部分 [i, j] 和 [j, i+len]，然后分別取出各自的數組 dp[i][j] 和 dp[j][i+len]，把對應的運算符也取出來，現在又變成了兩個數組中任取兩個數字進行運算，又整兩個 for 循環，所以總共整了5個 for 循環嵌套，啊呀媽呀，看這整的，看不暈你算我輸，參見代碼如下：

解法三：

class Solution {
public:
    vector<int> diffWaysToCompute(string input) {
        if (input.empty()) return {};
        vector<string> ops;
        int n = input.size();
        for (int i = 0; i < n; ++i) {
            int j = i;
            while (j < n && isdigit(input[j])) ++j;
            ops.push_back(input.substr(i, j - i));
            if (j < n) ops.push_back(input.substr(j, 1));
            i = j;
        }
        int cnt = (ops.size() + 1) / 2;
        vector<vector<vector<int>>> dp(cnt, vector<vector<int>>(cnt, vector<int>()));
        for (int i = 0; i < cnt; ++i) dp[i][i].push_back(stoi(ops[i * 2]));
        for (int len = 0; len < cnt; ++len) {
            for (int i = 0; i < cnt - len; ++i) {
                for (int j = i; j < i + len; ++j) {
                    vector<int> left = dp[i][j], right = dp[j + 1][i + len];
                    string op = ops[j * 2 + 1];
                    for (int num1 : left) {
                        for (int num2 : right) {
                            if (op == "+") dp[i][i + len].push_back(num1 + num2);
                            else if (op == "-") dp[i][i + len].push_back(num1 - num2);
                            else dp[i][i + len].push_back(num1 * num2);
                        }
                    }
                }
            }
        }
        return dp[0][cnt - 1];
    }
};

“C++實現添加括號的不同方式”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！