检查两个数学表达式是否等价

Question

我在一次采访中遇到了一个问题。我尝试解决它，但无法提出解决方案。问题是：

[已编辑] 第一部分：给你两个只有“+”运算符的表达式，检查给定的两个表达式在数学上是否等价。 例如，“A+B+C”等价于“A+(B+C)”。

第二部分：给你两个表达式，只有“+”和“-”运算符，检查给定的两个表达式在数学上是否等价。 例如“A+B-C”等价于“A-(-B+C)”。

我的思考过程：我正在考虑从给定的表达式构建表达式树并寻找某种相似性。但是我无法想出一个检查两个表达式树是否相同的好方法。

有人可以帮助我吗:) 提前谢谢！

Answer 1

只要运算是可交换的，我建议的解决方案是分配括号运算，然后按“变量”对术语进行排序，然后在它们之间运行聚合器，您应该会得到一串因子和符号。然后只需检查一组因素。

Answer 2

聚合变量计数，直到遇到左大括号，将减法视为添加否定变量。递归处理子表达式。

子表达式的内容可以直接聚合到计数中，您只需要正确考虑符号 - 无需为此任务创建实际的表达式树。代码中使用的TreeMap只是JDK中的排序映射实现。

代码利用了当前位置是Reader 状态的一部分这一事实，因此我们可以轻松地在递归调用的右括号之后继续解析，而无需以某种方式将该信息显式地交给调用者。

Java 实现（未经测试）：

class Expression {
   // Count for each variable name
   Map<String, Integer> counts = new TreeMap<>();

   Expression(Srring s) throws IOException {
     this(new StringReader(s));
   }

   Expression(Reader reader) throws IOException {
     int sign = 1;
     while (true) {
       int token = reader.read(); 
       switch (token) {
         case -1:  // Eof
         case ')':
           return;
         case '(':
           add(sign, new Expression(reader));
           sign = 1;
           break;
         case '+':
           break;
         case '-':
           sign = -sign;
           break;
         default:
           add(sign, String.valueOf((char) token));
           sign = 1;
           break;
       }
     }
   }

   void add(int factor, String variable) {
     int count = counts.containsKey(variable) ? counts.get(variable) : 0;
     counts.put(count + factor, variable);
   }

   void add(int sign, Expression expr) {
     for (Map.Entry<String,Integer> entry : expr.counts.entrySet()) {
       add(sign * entry.getVaue(), entry.getKey());
     }
   }

   void equals(Object o) {
     return (o instanceof Expression) 
        && ((Expression) o).counts.equals(counts);
   }

   // Not needed for the task, just added for illustration purposes.
   String toString() {
     StringBuilder sb = new StringBuilder();
     for (Map.Entry<String,Integer> entry : expr.counts.entrySet()) {
       if (sb.length() > 0) {
         sb.append(" + ");
       }
       sb.append(entry.getValue());  // count
       sb.append(entry.getKey());    // variable name
     }
     return sb.toString();
   }
 }

比较

new Expression("A+B-C").equals(new Expression("A-(-B+C)"))

P.S：添加了一个toString() 方法来更好地说明数据结构。

应该打印1A + 1B + -1C 作为示例。

P.P.P.P.S.：修正、简化、更好的解释。

Answer 3

您可以从左到右解析表达式并将它们简化为规范形式以便以直接的方式进行比较；唯一的复杂之处在于，当您遇到右括号时，您需要知道其关联的左括号前面是加号还是减号；您可以为此使用堆栈；例如：

function Dictionary() {
    this.d = [];
}
Dictionary.prototype.add = function(key, value) {
    if (!this.d.hasOwnProperty(key)) this.d[key] = value;
    else this.d[key] += value;
}
Dictionary.prototype.compare = function(other) {
    for (var key in this.d) {
        if (!other.d.hasOwnProperty(key) || other.d[key] != this.d[key]) return false;
    }
    return this.d.length == other.d.length;
}

function canonize(expression) {
    var tokens = expression.split('');
    var variables = new Dictionary();
    var sign_stack = [];
    var total_sign = 1;
    var current_sign = 1;

    for (var i in tokens) {
        switch(tokens[i]) {
            case '(' : {
                sign_stack.push(current_sign);
                total_sign *= current_sign;
                current_sign = 1;
                break;
            }
            case ')' : {
                total_sign *= sign_stack.pop();
                break;
            }
            case '+' : {
                current_sign = 1;
                break;
            }
            case '-' : {
                current_sign = -1;
                break;
            }
            case ' ' : {
                break;
            }
            default : {
                variables.add(tokens[i], current_sign * total_sign);
            }
        }
    }
    return variables;
}

var a = canonize("A + B + (A - (A + C - B) - B) - C");
var b = canonize("-C - (-A - (B + (-C)))");
document.write(a.compare(b));