LeetCode 770题解析：带变量多项式计算器的实现

1. 问题背景与核心挑战

这道LeetCode 770题"基本计算器IV"属于表达式解析与符号计算的经典难题。题目要求实现一个能够处理带变量的多项式表达式计算器，输出规范化的计算结果。与基础版计算器问题相比，其特殊之处在于需要处理：

• 变量组成的多项式表达式（如 2*a*b + 3*c + 1）
• 嵌套括号的多重优先级运算
• 同类项的合并与结果排序规范
• 输入表达式中的空格干扰处理

在实际工程中，这类需求常见于公式编辑器、科学计算软件等场景。我在金融量化系统开发中就遇到过类似需求——需要动态解析用户输入的风险计算公式，其中包含多种市场参数变量。

2. 解决方案设计思路

2.1 整体架构设计

经过多次尝试，最终确定采用双栈解析法的改进方案：

1. 词法分析层：将原始字符串转换为token流
2. 语法解析层：使用操作数栈和运算符栈处理优先级
3. 符号计算层：实现多项式运算规则
4. 结果规范化层：合并同类项并排序输出

java复制class Solution {
    private Map<String, Integer> evalMap;
    
    public List<String> basicCalculatorIV(String expression, 
                                        String[] evalvars, 
                                        int[] evalints) {
        // 实现代码...
    }
}

2.2 关键数据结构

设计Polynomial类封装多项式运算逻辑：

• Map<List<String>, Integer>存储单项式（如["a","b"]对应2表示2ab）
• 实现add(), multiply(), evaluate()等核心方法
• 重写compareTo()满足题目输出顺序要求

注意：单项式的变量列表必须保持字母序，这是合并同类项的关键前提

3. 核心算法实现细节

3.1 词法分析优化技巧

处理表达式字符串时容易忽略的几个细节：

1. 连续空格的处理：replaceAll("\\s+", " ")先规范化
2. 负数的识别：在tokenize阶段要将-5识别为整体而非-和5
3. 变量名校验：确保只包含小写字母（题目约束）

java复制private List<String> tokenize(String s) {
    List<String> tokens = new ArrayList<>();
    StringBuilder sb = new StringBuilder();
    for (char c : s.toCharArray()) {
        if (c == ' ') continue;
        if (c == '(' || c == ')' || c == '+' || c == '-' || c == '*') {
            if (sb.length() > 0) {
                tokens.add(sb.toString());
                sb.setLength(0);
            }
            tokens.add(String.valueOf(c));
        } else {
            sb.append(c);
        }
    }
    if (sb.length() > 0) tokens.add(sb.toString());
    return tokens;
}

3.2 运算符优先级处理

采用Dijkstra双栈算法的改进版本：

• 运算符栈需要处理*比+/-更高的优先级
• 遇到右括号时需要持续出栈直到匹配左括号
• 注意减法要转换为加负数（a - b → a + (-b)）

java复制private static final Map<String, Integer> PRIORITY = Map.of(
    "(", 0,
    "+", 1,
    "-", 1,
    "*", 2
);

while (!ops.isEmpty() && PRIORITY.get(ops.peek()) >= currPri) {
    Polynomial b = nums.pop();
    Polynomial a = nums.pop();
    nums.push(applyOp(a, b, ops.pop()));
}

3.3 多项式运算实现

多项式乘法是算法核心难点，需要实现：

1. 变量列表的合并与排序（Arrays.sort()）
2. 系数的相乘计算
3. 同类项的自动合并

java复制public Polynomial multiply(Polynomial that) {
    Polynomial res = new Polynomial();
    for (Map.Entry<List<String>, Integer> e1 : this.terms.entrySet()) {
        for (Map.Entry<List<String>, Integer> e2 : that.terms.entrySet()) {
            List<String> vars = new ArrayList<>();
            vars.addAll(e1.getKey());
            vars.addAll(e2.getKey());
            Collections.sort(vars);
            int coeff = e1.getValue() * e2.getValue();
            res.addTerm(vars, coeff);
        }
    }
    return res;
}

4. 调试与边界情况处理

4.1 常见报错场景

1. 空表达式输入：应返回空列表而非null
2. 纯数字表达式：如"123"要转换为常数项
3. 多重括号嵌套：((a + b)*c)需要正确处理
4. 变量替换冲突：evalvars中的变量名可能与表达式变量重名

4.2 性能优化点

1. 多项式运算时使用TreeMap自动维护变量顺序
2. 提前计算并缓存evalvars的映射关系
3. 在tokenize阶段就完成数字/变量的分类识别

java复制// 变量替换优化
evalMap = new HashMap<>();
for (int i = 0; i < evalvars.length; i++) {
    evalMap.put(evalvars[i], evalints[i]);
}

5. 完整实现参考

以下是经过LeetCode测试通过的完整解决方案：

java复制class Solution {
    private Map<String, Integer> evalMap;
    
    public List<String> basicCalculatorIV(String expression, String[] evalvars, int[] evalints) {
        evalMap = new HashMap<>();
        for (int i = 0; i < evalvars.length; i++) {
            evalMap.put(evalvars[i], evalints[i]);
        }
        return parse(expression).toList();
    }
    
    private Polynomial parse(String expr) {
        List<String> tokens = tokenize(expr);
        Deque<Polynomial> nums = new ArrayDeque<>();
        Deque<String> ops = new ArrayDeque<>();
        
        for (int i = 0; i < tokens.size(); i++) {
            String token = tokens.get(i);
            if (token.equals("(")) {
                ops.push(token);
            } else if (token.equals(")")) {
                while (!ops.peek().equals("(")) {
                    nums.push(applyOp(nums.pop(), nums.pop(), ops.pop()));
                }
                ops.pop();
            } else if (isOp(token)) {
                while (!ops.isEmpty() && priority(ops.peek()) >= priority(token)) {
                    nums.push(applyOp(nums.pop(), nums.pop(), ops.pop()));
                }
                ops.push(token);
            } else {
                Polynomial p;
                if (Character.isDigit(token.charAt(0))) {
                    p = new Polynomial(Integer.parseInt(token));
                } else if (evalMap.containsKey(token)) {
                    p = new Polynomial(evalMap.get(token));
                } else {
                    p = new Polynomial(Arrays.asList(token), 1);
                }
                nums.push(p);
            }
        }
        
        while (!ops.isEmpty()) {
            nums.push(applyOp(nums.pop(), nums.pop(), ops.pop()));
        }
        return nums.isEmpty() ? new Polynomial() : nums.pop();
    }
    
    private Polynomial applyOp(Polynomial b, Polynomial a, String op) {
        switch (op) {
            case "+": return a.add(b);
            case "-": return a.add(b.multiply(new Polynomial(-1)));
            case "*": return a.multiply(b);
            default: throw new IllegalArgumentException();
        }
    }
    
    // 辅助方法省略...
}

class Polynomial {
    Map<List<String>, Integer> terms;
    
    public Polynomial() { terms = new TreeMap<>(this::compareTerm); }
    
    public Polynomial(int val) { 
        this(); 
        if (val != 0) terms.put(new ArrayList<>(), val);
    }
    
    public Polynomial(List<String> vars, int coeff) {
        this();
        if (coeff != 0) terms.put(new ArrayList<>(vars), coeff);
    }
    
    // 其他方法实现...
}

6. 复杂度分析与优化方向

6.1 时间复杂度

假设表达式长度为N：

• Tokenize：O(N)
• 双栈解析：O(N)
• 多项式运算：最坏O(M^2)（M为单项式数量）
• 总体：O(N + M^2)

6.2 空间优化建议

1. 使用String.intern()减少重复变量名的存储
2. 多项式运算时复用中间结果容器
3. 对于大型表达式可采用分块处理策略

在实际工程实现中，可以考虑引入多项式运算的缓存机制。我在量化系统开发中就建立了一个表达式缓存池，将解析过的表达式AST缓存起来，当相同表达式再次出现时直接复用计算结果，性能提升显著。