小黑开始尝试有道翻译爬虫逆向，身体逐渐好转开始跑步,排练舞狮去部里彩排，跟小元吃潮汕牛肉，跟思琪老师吃鸡，跟逗兄你恶心吃重庆火锅，开始尝试瑜伽课的leetcode之旅:32. 最长有效括号

最新推荐文章于 2024-07-24 09:09:34 发布

爱喝喜茶爱吃烤冷面的小黑黑

最新推荐文章于 2024-07-24 09:09:34 发布

阅读量512

点赞数 7

分类专栏：小黑的日常leetcode之旅文章标签：爬虫 leetcode 算法

本文链接：https://blog.csdn.net/qq_37418807/article/details/136128975

版权

小黑的日常leetcode之旅专栏收录该内容

225 篇文章 1 订阅

订阅专栏

小黑脑补了一种巧妙方法，max(左起左括号可以匹配右括号的滑动窗口结果，右起右括号匹配左括号的的滑动窗口结果)，独立解决了一道困难难度的题，NB!!!

小黑代码

class Solution:
    def longestValidParentheses(self, s: str) -> int:
        def get_res(s):
            # 字符串长度
            n = len(s)
            # 定义窗口栈
            q = []
            # 定义双指针
            head = 0
            tail = 0
            # 结果变量
            res = 0
            # 开始进行双指针操作
            while tail < n:
                # 左括号，入栈
                if s[tail] == '(':
                    q.append(s[tail])
                else:
                    # 栈里有元素，出栈
                    if q:
                        q.pop()
                    # 非法情况，指针跳过，清空栈
                    else:
                        head = tail + 1
                        q = []
                tail += 1
                if not q and tail - head > res:
                    res = tail - head
            return res
        # 将字符串翻转，左右括号颠倒
        s_reverse = []
        for c in s[::-1]:
            if c == '(':
                s_reverse.append(')')
            else:
                s_reverse.append('(')
        s_reverse = ''.join(s_reverse)
        return max(get_res(s_reverse), get_res(s))

在这里插入图片描述

动态规划法

class Solution:
    def longestValidParentheses(self, s: str) -> int:
        '''
        思路:
            令dp[i]为第i个字符为结尾对应的有效长度
                如果s[i]=='(',有效长度为0，因为以"("为结尾的字符串一定不是有效字符
                如果s[i]==')'
                    假设dp[i-1] = l
                        如果s[i-l-1]=='('
                            dp[i] = dp[i-l-2]+l+2(不考虑越界的情况)
                        如果s[i-l-1]==')'
                            dp[i] = 0
                        
        '''
        # 字符串长度
        n = len(s)
        if not n:
            return 0
        # 初始化动态规划数组
        dp = [0] * n
        # 结果变量
        res = 0
        for i in range(1, n):
            if s[i] == ')' :
                # 上一个字符为结尾的最长有效子串长度
                l = dp[i-1]
                # xxx(***)的情况
                if i-l-1 >= 0 and s[i-l-1] == '(':
                    dp[i] = dp[i-1] + 2
                    if i-l-2 >= 0:
                        dp[i] += dp[i-l-2]
                res = max(dp[i], res)
        return res

在这里插入图片描述

栈

class Solution:
    def longestValidParentheses(self, s: str) -> int:
        # 字符串长度
        n = len(s)
        if not s:
            return 0        
        # 初始化栈，栈顶元素记录以当前第i个字符为结尾，对应有效子串初始位置的前驱字符编号
        q = [-1]
        # 结果变量
        res = 0
        # 开始遍历字符串
        for i in range(n):
            if s[i] == '(':
                q.append(i)
            else:
                q.pop()
                # 栈不为空，证明当前字符为结尾的有效子串存在，利用子串长度更新res后续子串的
                if q:
                    res = max(i-q[-1], res)
                # 栈不为空，证明当前字符为结尾的有效子串不存在，将当前字符编号作为栈底元素
                else:
                    q.append(i)
        return res

在这里插入图片描述

滑动窗口法

class Solution:
    def longestValidParentheses(self, s: str) -> int:
        # 字符串长度
        n = len(s)
        # 通过滑动窗口，列举左括号大于等于右括号数的子串，记录有效字符串长度
        # 窗口双指针
        left = 0
        right = 0
        # 结果变量
        res = 0
        for i in range(n):
            if s[i] == '(':
                left += 1
            else:
                right += 1
            if left < right:
                left = right = 0
            elif left == right:
                res = max(res, right*2)
        # 反过来
        left = 0
        right = 0
        for i in range(n-1, -1, -1):
            if s[i] == ')':
                right += 1
            else:
                left += 1
            if left > right:
                left = right = 0
            elif left == right:
                res = max(res, left * 2)
        return res