长期加班，公司将所有人下班时间统一显示成 17 点，员工集体控诉

奇瑞大爆发

近日，有爆料称奇瑞上海属地员工发起多项投诉，控诉奇瑞非法加班。

引发矛盾的导火线：奇瑞将所有员工的下班打卡时间统一显示为 17 点。

但真实的情况是：

1. 2024 年年初，奇瑞曾严抓考勤，对于踩点人数多和出勤率低的部门领导进行约谈
2. 奇瑞加班没有正式加班费，超过三个小时的加班时间，会发放 10 元餐补
3. 奇瑞的薪资水平不足蔚小理的一半，就工作强度而言，普遍都是 896 工作制

员工长期受压迫，加上现在公司疑似为了上市，统一修改了员工的下班时间显示。

越来越多的奇瑞员工参与到曝光活动中。

从刚开始的粗略爆料到现在越来越多细则浮出表面：

与此同时，几乎每一篇爆料底下，都有不少带着「企业认证」徽章的网友进行回应：

这还没完，奇瑞之前的黑历史，也随着爆料让大家给重温了一遍。

除了将周六定义成「奋斗者的工作日」，不给调休也不给加班费，平时请假也要抢名额，有年假却用不了。

每一件事的离谱程度，都刷新了我的想象。

在搜索引擎查了一下奇瑞的上市历史，18 年来四次申请上市失败，今年是第 19 年，衷心祝愿其再来一次。

...

回归主题。

来一道和「腾讯」相关的算法题。

题目描述

平台：LeetCode

题号：241

给你一个由数字和运算符组成的字符串 expression，按不同优先级组合数字和运算符，计算并返回所有可能组合的结果。你可以按任意顺序返回答案。

生成的测试用例满足其对应输出值符合 32 位整数范围，不同结果的数量不超过 $10^4$ 。

示例 1：

输入：expression = "2-1-1"

输出：[0,2]

解释：
((2-1)-1) = 0 
(2-(1-1)) = 2

示例 2：

输入：expression = "2*3-4*5"

输出：[-34,-14,-10,-10,10]

解释：
(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

提示：

• $1 <= expression.length <= 20$
• expression 由数字和算符 '+'、'-' 和 '*' 组成。
• 输入表达式中的所有整数值在范围 $[0, 99]$

DFS

为了方便，我们令 expression 为 s。

数据范围为 20，且要统计所有的计算结果，我们可以运用 DFS 爆搜所有方案。

给定的 s 只有数字和运算符，我们可以根据运算符将式子分为左右两部分，设计递归函数 List<Integer> dfs(int l, int r)，含义为搜索子串 $s[l...r]$ 的所有运算结果。

最终答案为 dfs(0,n-1)，其中 n 为入参字符串的长度，同时我们有显而易见的递归出口：当给定的 $s[l...r]$ 不包含任何运算符时，搜索结果为 $s[l...r]$ 所代表的数字本身。

考虑如何对任意 $s[l...r]$ 进行计算：我们可以通过枚举 $s[l...r]$ 范围内的所有的运算符位置来进行爆搜，假设当前枚举到的 $s[i]$ 为运算符，我们可以递归运算符的左边 dfs(l,i-1) 拿到左边所有的结果，递归运算符右边 dfs(i+1,r) 拿到右边的所有结果，结合「乘法原理」即可知道以当前运算符 $s[i]$ 为分割点的表达式的所有方案。

不难发现，上述过程都是由「小表达式」的结果推导出「大表达式」的结果，因此也可以运用「区间 DP」方式进行求解，复杂度与 DFS 一致。

Java 代码：

class Solution {
    char[] cs;
    public List<Integer> diffWaysToCompute(String s) {
        cs = s.toCharArray();
        return dfs(0, cs.length - 1);
    }
    List<Integer> dfs(int l, int r) {
        List<Integer> ans = new ArrayList<>();
        for (int i = l; i <= r; i++) {
            if (cs[i] >= '0' && cs[i] <= '9') continue;
            List<Integer> l1 = dfs(l, i - 1), l2 = dfs(i + 1, r);
            for (int a : l1) {
                for (int b : l2) {
                    int cur = 0;
                    if (cs[i] == '+') cur = a + b;
                    else if (cs[i] == '-') cur = a - b;
                    else cur = a * b;
                    ans.add(cur);
                }
            }
        }
        if (ans.isEmpty()) {
            int cur = 0;
            for (int i = l; i <= r; i++) cur = cur * 10 + (cs[i] - '0');
            ans.add(cur);
        }
        return ans;
    }
}

C++ 代码：

class Solution {
public:
    string s;
    vector<int> diffWaysToCompute(string _s) {
        s = _s;
        return dfs(0, s.size() - 1);
    }
    vector<int> dfs(int l, int r) {
        vector<int> ans;
        for (int i = l; i <= r; i++) {
            if (isdigit(s[i])) continue; 
            auto l1 = dfs(l, i - 1), l2 = dfs(i + 1, r);
            for (int a : l1) {
                for (int b : l2) {
                    int cur = 0;
                    if (s[i] == '+') cur = a + b;
                    else if (s[i] == '-') cur = a - b;
                    else cur = a * b;
                    ans.push_back(cur);
                }
            }
        }
        if (ans.empty()) {
            int cur = 0;
            for (int i = l; i <= r; i++) cur = cur * 10 + (s[i] - '0');
            ans.push_back(cur);
        }
        return ans;
    }
};

Python 代码：

class Solution:
    def diffWaysToCompute(self, cs: str) -> List[int]:        
        def dfs(l: int, r: int) -> List[int]:
            ans = []
            for i in range(l, r + 1):
                if '0' <= cs[i] <= '9': continue
                l1, l2 = dfs(l, i - 1), dfs(i + 1, r)
                for a, b in product(l1, l2):
                    cur = 0
                    if cs[i] == '+':
                        cur = a + b
                    elif cs[i] == '-':
                        cur = a - b
                    else:
                        cur = a * b
                    ans.append(cur)
            if not ans:
                cur = 0
                for i in range(l, r + 1):
                    cur = cur * 10 + (ord(cs[i]) - ord('0'))
                ans.append(cur)
            return ans
        return dfs(0, len(cs) - 1)

TypeScript 代码：

function diffWaysToCompute(cs: string): number[] {
    const dfs = function(l: number, r: number): number[] {
        const ans = [];
        for (let i = l; i <= r; i++) {
            if ("0" <= cs[i] && cs[i] <= "9") continue;
            const l1 = dfs(l, i - 1), l2 = dfs(i + 1, r);
            for (const a of l1) {
                for (const b of l2) {
                    let cur = 0;
                    if (cs[i] === "+") cur = a + b;
                    else if (cs[i] === "-") cur = a - b;
                    else cur = a * b;
                    ans.push(cur);
                }
            }
        }
        if (ans.length == 0) {
            let cur = 0;
            for (let i = l; i <= r; i++) cur = cur * 10 + (parseInt(cs[i]) - 0);
            ans.push(cur);
        }
        return ans;
    }
    return dfs(0, cs.length - 1);
};

• 时间复杂度：复杂度与最终结果数相关，最终结果数为「卡特兰数」，复杂度为 $O(C_{n})$
• 空间复杂度：复杂度与最终结果数相关，最终结果数为「卡特兰数」，复杂度为 $O(C_{n})$