leetcode：301. 删除无效的括号【括号套路+bfs优化】

最新推荐文章于 2025-06-24 15:01:12 发布

白速龙王的回眸

最新推荐文章于 2025-06-24 15:01:12 发布

阅读量257

点赞数 1

CC 4.0 BY-SA版权

分类专栏： leetcode leetcode难题文章标签： leetcode 宽度优先算法

本文链接：https://blog.csdn.net/weixin_40986490/article/details/125022314

leetcode 同时被 2 个专栏收录

781 篇文章

订阅专栏

leetcode难题

416 篇文章

订阅专栏

本文介绍两种去除无效括号的方法：状态压缩与BFS。状态压缩适用于较小字符串，通过位操作跳过无效组合；BFS则从原始字符串逐步删除括号，直至找到所有合法组合。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在这里插入图片描述

分析

简单的括号check函数
然后一开始想的是状态压缩判断
但是这样会遍历到很多无效情况
因此，我们可以考虑从原始s一个个括号删除（因为是最小删除）
这样一旦遇到满足的删除个数立即返回即可，不需要额外多余的遍历

无脑状态压缩

class Solution:
    def removeInvalidParentheses(self, s: str) -> List[str]:
        # 状态压缩
        maxLength = 0
        ans = set()
        n = len(s)

        # 字母的位置不能删
        alpha = []
        for i in range(n):
            if s[i] in ascii_lowercase:
                alpha.append(i)
        #print(alpha)

        # 检查是否有效
        def check(s):
            # 辅助栈
            st = []
            for c in s:
                if c in ascii_lowercase:
                    continue
                if st and st[-1] == '(' and c == ')':
                    st.pop()
                else:
                    st.append(c)
            #print(st)
            return len(st) == 0


        # 状态压缩（但是对字母是不必要的）
        for i in range(1 << n):
            si = bin(i)[2:].zfill(n)
            # 保证不删掉字母
            flag = True
            for j in alpha:
                if si[j] == '0':
                    flag = False
                    break
            if not flag:
                continue
            
            now = ''
            for j, v in enumerate(si):
                if v == '1':
                    now += s[j]
            
            if len(now) < maxLength:
                continue
            
            if check(now) and len(now) == maxLength:
                ans.add(now)           
            elif check(now) and len(now) > maxLength:
                maxLength = len(now)
                ans = set()
                ans.add(now)
        
        return list(ans)

bfs解决最小删除问题（从原str开始删括号）

class Solution:
    def removeInvalidParentheses(self, s: str) -> List[str]:

        # 检查是否有效
        def check(s):
            # 辅助栈
            st = []
            for c in s:
                if c in ascii_lowercase:
                    continue
                if st and st[-1] == '(' and c == ')':
                    st.pop()
                else:
                    st.append(c)
            #print(st)
            return len(st) == 0

        ans = []

        # 使用bfs逐个括号删除（忽略字母干扰）
        curSet = set([s])
        while curSet:
            # 如果当前set中有合法的就放进去ans
            ans = [s for s in curSet if check(s)]
            if ans:  
                return ans
            nextSet = set()
            # 针对当前set的每一个砍掉一个括号
            for s in curSet:
                for i, c in enumerate(s):
                    if c == '(' or c == ')':
                        nextSet.add(s[:i] + s[i + 1:])
            curSet = nextSet