leetcode1106

做了一个解，但是WA，54/70，这个无法通过的测试用例有300个字符，太复杂了，我现在无法通过测试用例分析出哪里写的不对，感觉换一个思路更好一些：

class Solution:
    def parseBoolExpr(self, expression: str) -> bool:
        n = len(expression)
        opstack = []
        boolstack = []
        savenum = []
        curnum = 0
        for i in range(n):
            cur = expression[i]
            if cur == '(':
                if curnum > 0:
                    savenum.append(curnum)
                    curnum = 0
            elif cur == ')':
                op = opstack.pop(-1)
                if op == '!':
                    boolstack[-1] = not boolstack[-1]
                else:
                    if op == '&':
                        bsop = True
                        bn = len(boolstack)
                        blist = boolstack[bn-curnum:]
                        while curnum > 0:
                            boolstack.pop()
                            curnum -= 1
                        for b in blist:
                            bsop = bsop and b
                        boolstack.append(bsop)
                    else:
                        bsop = False
                        bn = len(boolstack)
                        blist = boolstack[bn-curnum:]
                        while curnum > 0:
                            boolstack.pop()
                            curnum -= 1
                        for b in blist:
                            bsop = bsop or b
                        boolstack.append(bsop)
                    if len(savenum) > 0:
                        pnum = savenum.pop(-1)
                        curnum = pnum + 1
                    else:
                        curnum = 1
            elif cur == '&' or cur == '|' or cur == '!':
                opstack.append(cur)
            elif cur == 't' or cur == 'f':
                curnum += 1
                bl = True if cur == 't' else False
                boolstack.append(bl)
            elif cur == ',':
                continue
            else:
                print('error')
        return boolstack.pop(-1)

下面给出一个AC的解，这个和我的思路接近，使用栈来存储运算顺序，使用set()来进行括号内部的运算，可以减少手工运算的错误。

参考：https://leetcode.com/problems/parsing-a-boolean-expression/discuss/323390/Python-simple-solution-using-stack-easy-to-understand

class Solution(object):
    def parseBoolExpr(self, expression):
        """
        :type expression: str
        :rtype: bool
        """
        stack = []
        for e in expression:
            if e in '!|&ft(':
                stack.append(e)
            if e == ')':
                exp = set()
                while stack:
                    b = stack.pop()
                    if b != '(':
                        exp.add(True if b == 't' else False)
                    else:
                        operator = stack.pop()
                        if operator == '&':
                            r = all(exp) 
                        if operator == '|':
                            r = any(exp)
                        if operator == '!':
                            r = not all(exp)
                        stack.append('t' if r else 'f')
                        break
        return True if stack[-1] == 't' else False   

算法中的本质和核心的问题，终究还是数学问题。

习惯性不擅长数学的我，算法水平也就是这样了。