LeetCode 分治法

241. 为运算表达式设计优先级

给定一个含有数字和运算符的字符串，为表达式添加括号，改变其运算优先级以求出不同的结果。你需要给出所有可能的组合的结果。有效的运算符号包含 +, - 以及 * 。

• 分治思想：

  • 将加括号转化为，对每个运算符号，先执行处理两侧的数学表达式，再处理此运算符号。
  • 利用递归将当前遍历符号的左右两侧表达式继续拆分。
  • 边界情况下，字符串无运算符号，只有数字。

• 例：5 + 3 * 4 + 2

  • left -> 5
  • right -> 3 * 4 + 2
    • left -> 3
    • right -> 4 + 2
      • left -> 4
      • right -> 2
    • left -> 3 * 4
      • left -> 3
      • right -> 4
    • right -> 2
  • left : 5, right: 3 * (4 + 2) = 18, (3 * 4) + 2 = 14
  • (3 * 4 + 2); (3 * 4) + 2; 3 * (4 + 2); 前两种结果相同

class Solution {
public:
    vector<int> diffWaysToCompute(string expression) {
        int n = expression.length();
        vector<int> ways;
        for (int i = 0; i < n; i++) {
            char c = expression[i];
            if (c == '+' || c == '-' || c == '*') {
            	// 符号左右两侧继续划分
                vector<int> left = diffWaysToCompute(expression.substr(0, i));
                vector<int> right = diffWaysToCompute(expression.substr(i + 1));
                for (const int& l : left) {
                    for (const int& r : right) {
                        switch(c) {
                            case '+': ways.push_back(l + r); break;
                            case '-': ways.push_back(l - r); break;
                            case '*': ways.push_back(l * r); break;
                        }
                    }
                }
            }
        }
        if (ways.empty()) ways.push_back(stoi(expression)); // 边界情况处理
        return ways;
    }
};

• 记忆化存储
  • 某些被划分的字符串可能重复出现多次，可以使用hash map将这些结果存储起来，再次遍历到该字符串时直接查询存储的结果。

class Solution {
public:
    unordered_map<string, vector<int>> strMap; // 外部建立哈希映射表
    vector<int> diffWaysToCompute(string expression) {
        int n = expression.length();
        // 查看哈希表中是否存储了该表达式划分的结果
        if (strMap.count(expression)) {
            return strMap[expression];
        }
        vector<int> ways;
        for (int i = 0; i < n; i++) {
            char c = expression[i];
            if (c == '+' || c == '-' || c == '*') {
                vector<int> left = diffWaysToCompute(expression.substr(0, i));
                // 将左侧表达式及其对应的结果放入哈希映射表中
                pair<string, vector<int>> instance1(expression.substr(0, i), left);
                strMap.insert(instance1);
                vector<int> right = diffWaysToCompute(expression.substr(i + 1));
                pair<string, vector<int>> instance2(expression.substr(i + 1), right);
                strMap.insert(instance2);
                for (const int& l : left) {
                    for (const int& r : right) {
                        switch(c) {
                            case '+': ways.push_back(l + r); break;
                            case '-': ways.push_back(l - r); break;
                            case '*': ways.push_back(l * r); break;
                        }
                    }
                }
            }
        }
        if (ways.empty()) ways.push_back(stoi(expression));
        return ways;
    }
};

• 动态规划：
  • 从下而上处理
  • dp[i][j][] 表示第 i 个数至第 j 个数的所有可能运算结果
  • j = i -> 0 方向计算 dp[j][i]；设 i = 3；j = 3，2，1，0；则先计算得到dp[3][3]，dp[2][3]，dp[1][3]，dp[0][3]；dp[2][3] = dp[2][2] * dp[3][3]；dp[1][3] = dp[1][1] * dp[2][3]； dp[1][2] * dp[3][3]；
  • j = 0 -> i 方向计算 dp[j][i]；设 i = 3；j = 0，1，2，3；则先计算dp[0][3]，但是dp[0][3] = dp[0][0] * dp[1][3]；dp[0][1] * dp[2][3]; dp[0][2] * dp[3][3]；的结果，若按此顺序，dp[2][3]的结果还未计算，因此无法得到正确结果；

class Solution {
public:
    vector<int> diffWaysToCompute(string expression) {
        istringstream ss(expression + "+"); // 增加一个标志便于截止
        vector<int> data;
        vector<char> ops;
        int num = 0;
        char op = ' ';
        // 获取表达式中的数字和运算符号
        while (ss >> num && ss >> op) {
            data.push_back(num);
            ops.push_back(op);
        }
        int n = data.size();
        vector<vector<vector<int>>> dp(n, vector<vector<int>>(n, vector<int>()));
        for (int i = 0; i < n; i++) {
            for (int j = i; j >= 0; j--) {
                if (i == j) {
                    dp[j][i].push_back(data[i]); // 第 i 个数字本身
                }else {
                    for (int k = j; k < i; k += 1) { // 自 j 向 i 步进，考虑所有情况
                    	// 计算得到第 j 个数到第 i 个数的所有运算结果，其用 k 进行分割
                    	// j 至 i 可以分为 j 至 k 与 k + 1 到 i
                        for (const int& left : dp[j][k]) {
                            for (const int& right : dp[k + 1][i]) {
                                int val = 0;
                                // 以 k 为分界，所以调用第 k 个运算符
                                switch(ops[k]) {
                                    case '+' : val = left + right; break;
                                    case '-' : val = left - right; break;
                                    case '*' : val = left * right; break;
                                }
                                dp[j][i].push_back(val); // 存储结果
                            }
                        }
                    }
                }
            }
        }
        return dp[0][n - 1];
    }
};