LeetCode 1106. 解析布尔表达式

1106. 解析布尔表达式

布尔表达式 是计算结果不是 true 就是 false 的表达式。有效的表达式需遵循以下约定：

• 't'，运算结果为 true
• 'f'，运算结果为 false
• '!(subExpr)'，运算过程为对内部表达式 subExpr 进行 逻辑非（NOT）运算
• '&(subExpr1, subExpr2, ..., subExprn)'，运算过程为对 2 个或以上内部表达式 subExpr1, subExpr2, ..., subExprn 进行 逻辑与（AND）运算
• '|(subExpr1, subExpr2, ..., subExprn)'，运算过程为对 2 个或以上内部表达式 subExpr1, subExpr2, ..., subExprn 进行 逻辑或（OR）运算

给你一个以字符串形式表述的 布尔表达式 expression，返回该式的运算结果。

题目测试用例所给出的表达式均为有效的布尔表达式，遵循上述约定。

示例 1：

输入：expression = "&(|(f))"
输出：false
解释：
首先，计算 |(f) --> f ，表达式变为 "&(f)" 。
接着，计算 &(f) --> f ，表达式变为 "f" 。
最后，返回 false 。

示例 2：

输入：expression = "|(f,f,f,t)"
输出：true
解释：计算 (false OR false OR false OR true) ，结果为 true 。

示例 3：

输入：expression = "!(&(f,t))"
输出：true
解释：
首先，计算 &(f,t) --> (false AND true) --> false --> f ，表达式变为 "!(f)" 。
接着，计算 !(f) --> NOT false --> true ，返回 true 。

提示：

• 1 <= expression.length <= 2 * 10^4
• expression[i] 为 '('、')'、'&'、'|'、'!'、't'、'f' 和 ',' 之一

---

提示 1

Write a function "parse" which calls helper functions "parse_or", "parse_and", "parse_not".

解法1：栈

给定的字符串 expression 是有效的布尔表达式，每个运算符后面都有一对括号，括号中有一个或多个表达式。其中，逻辑非运算符后面的括号中有一个表达式，逻辑与运算符和逻辑或运算符后面的括号中有两个或以上表达式。

可以使用栈实现布尔表达式的解析。从左到右遍历布尔表达式，对于每种类型的字符，执行相应的操作：

• 如果当前字符是逗号，则跳过该字符；
• 如果当前字符是除了逗号和右括号以外的任意字符，则将该字符添加到栈内；
• 如果当前字符是右括号，则一个表达式遍历结束，需要解析该表达式的值，并将结果添加到栈内：

1. 将栈内字符依次弹出，直到栈顶字符是左括号，然后将左括号和运算符从栈内弹出，记录弹出的 ‘t’ 和 ‘f’ 的个数；
2. 根据运算符以及 ‘t’ 和 ‘f’ 的个数计算表达式的值，并将表达式的值添加到栈内：

• 如果运算符是 ‘!’，则是逻辑非运算符，表达式的值为括号内的值取反，因此当 ‘f’ 的个数等于 1 时表达式的值为 ‘t’，否则表达式的值为 ‘f’；
• 如果运算符是 ‘&’，则是逻辑与运算符，当括号内的所有值都是 ‘t’ 时结果是 ‘t’，否则结果是 ‘f’，因此当 ‘f’ 的个数等于 0 时表达式的值为 ‘t’，否则表达式的值为 ‘f’；
• 如果运算符是 ‘|’，则是逻辑或运算符，当括号内至少有一个值都是 ‘t’ 时结果是 ‘t’，否则结果是 ‘f’，因此当 ‘t’ 的个数大于 0 时表达式的值为 ‘t’，否则表达式的值为 ‘f’；

遍历结束之后，栈内只有一个字符，该字符为 ‘t’ 或 ‘f’，如果字符为 ‘t’ 则返回 true，如果字符为 ‘f’ 则返回 false。

Java版：

class Solution {
    public boolean parseBoolExpr(String expression) {
        Deque<Character> stack = new ArrayDeque<>();
        for (int i = 0; i < expression.length(); i++) {
            char ch = expression.charAt(i);
            if (ch == ',') {
                continue;
            } else if (ch != ')') {
                stack.push(ch);
                continue;
            } 
            int t = 0;
            int f = 0;
            while (stack.peek() != '(') {
                if (stack.pop() == 't') {
                    t++;
                } else {
                    f++;
                }
            }
            stack.pop();
            char op = stack.pop();
            switch (op) {
                case '!':
                    stack.push(f == 1 ? 't' : 'f');
                    break;
                case '&':
                    stack.push(f == 0 ? 't' : 'f');
                    break;
                case '|':
                    stack.push(t == 0 ? 'f' : 't');
                    break;
            }
        }
        return stack.peek() == 't';
    }
}

Python3版：

class Solution:
    def parseBoolExpr(self, expression: str) -> bool:
        stack = []
        for ch in expression:
            if ch == ',':
                continue
            elif ch != ')':
                stack.append(ch)
                continue  
            t = f = 0
            while stack[-1] != '(':
                if stack.pop() == 't':
                    t += 1
                else:
                    f += 1
            stack.pop()
            op = stack.pop()
            if op == '!':
                stack.append('t' if f == 1 else 'f')
            elif op == '&':
                stack.append('t' if f == 0 else 'f')
            elif op == '|':
                stack.append('t' if t > 0 else 'f')
        return stack[-1] == 't'

复杂度分析

• 时间复杂度：O(n)，其中 n 是布尔表达式 expression 的长度。需要遍历布尔表达式一次并解析。
• 空间复杂度：O(n)，其中 n 是布尔表达式 expression 的长度。空间复杂度主要取决于栈空间，栈内字符个数不超过 n。