LeetCode 1106 Parsing A Boolean Expression (分治，模拟)

Return the result of evaluating a given boolean expression, represented as a string.

An expression can either be:

• "t", evaluating to True;
• "f", evaluating to False;
• "!(expr)", evaluating to the logical NOT of the inner expression expr;
• "&(expr1,expr2,...)", evaluating to the logical AND of 2 or more inner expressions expr1, expr2, ...;
• "|(expr1,expr2,...)", evaluating to the logical OR of 2 or more inner expressions expr1, expr2, ...

Example 1:

Input: expression = "!(f)"
Output: true

Example 2:

Input: expression = "|(f,t)"
Output: true

Example 3:

Input: expression = "&(t,f)"
Output: false

Example 4:

Input: expression = "|(&(t,f,t),!(t))"
Output: false

Constraints:

• 1 <= expression.length <= 20000
• expression[i] consists of characters in {'(', ')', '&', '|', '!', 't', 'f', ','}.
• expression is a valid expression representing a boolean, as given in the description.

题目链接：https://leetcode.com/problems/parsing-a-boolean-expression/

题目大意：给一个合法的布尔表达式，判断是true还是false

题目分析：不断拆分子表达式，用栈模拟，对与和或的操作可以用短路表达式优化时间，hard 模拟一发过~

1ms，时间击败90.49%

class Solution {
    
    class Pos {
        int st, ed;
        Pos(int st, int ed) {
            this.st = st;
            this.ed = ed;
        }
    }
    
    public List<Pos> getSubExprPos(char[] s, int l, int r) {
        List<Pos> ans = new ArrayList<>();
        
        int top = 0, st = l;
        for (int i = l; i <= r; i++) {
            if (top == 0 && (s[i] == 'f' || s[i] == 't')) {
                ans.add(new Pos(i, i));
                st = i + 2;
                continue;
            } else if (s[i] == '(') {
                top++;
            } else if (s[i] == ')') {
                top--;
            }
            if (top == 0 && i + 1 <= r && s[i + 1] == ',') {
                ans.add(new Pos(st, i));
                st = i + 2;
            }
        }
        if (st <= r) {
            ans.add(new Pos(st, r));
        }
        // for (int i = 0; i < ans.size(); i++) {
        //     System.out.println("l = " + ans.get(i).st + " r = " + ans.get(i).ed);
        // }
        // System.out.println();
        return ans;
    }

    public boolean dfs(char[] s, int l, int r) {
        if (s[l] == '!') {
            return !dfs(s, l + 2, r - 1);
        } else if (s[l] == '|') {
            boolean res = false;
            for (Pos p : getSubExprPos(s, l + 2, r - 1)) {
                res |= dfs(s, p.st, p.ed);
                if (res) {
                    return true;
                }
            }
            return false;
        } else if (s[l] == '&') {
            boolean res = true;
            for (Pos p : getSubExprPos(s, l + 2, r - 1)) {
                res &= dfs(s, p.st, p.ed);
                if (!res) {
                    return false;
                }
            }
            return true;
        } else if (s[l] == 'f') {
            return false;
        }
        return true;
    }
    
    
    public boolean parseBoolExpr(String expression) {
        char[] s = expression.toCharArray();
        return dfs(s, 0, s.length - 1);
    }
}