給定一個只包含 '('和 ')'的字串，找出最長的包含有效括號的子串的長度。

示例1:

輸入: "(()"
輸出: 2
解釋: 最長有效括號子串為 "()"
示例 2:

輸入: ")()())"
輸出: 4
解釋: 最長有效括號子串為 "()()"

來源：力扣（LeetCode）
連結：https://leetcode-cn.com/problems/longest-valid-parentheses

棧

典型的棧結構

棧中初始化一個 -1，作為分割符；

遇到'('入棧，遇到')'出棧；

當棧為空時且當前掃到的是')'，把它入棧作為分割符；

class Solution:
    def longestValidParentheses(self, s: str) -> int:
        
 
if not s:
            return 0
        res=0
        stack=[-1]
        for i in range(len(s)):
            if s[i]=='(':
                stack.append(i)
            else:
                stack.pop()
                if not stack:
                    stack.append(i)
                else:
                    res
 
=max(res,i-stack[-1])
        return res

• time：O(N)
• space：O(N)

暴力=>優化

萬物始於暴力，我們來看一下能不能暴出其他什麼方法

先寫出暴力

class Solution:
    def longestValidParentheses(self, s: str) -> int:
        n = len(s)
        res = 0

        def Cnt(start):
            cnt = 0
            res = 0
            for i in range(start, n):
                
 
if s[i] == '(':
                    cnt += 1
                if s[i] == ')':
                    cnt -= 1
                if cnt < 0:
                    return i - start
                if cnt == 0:
                    res = max(res, i - start + 1)
            return res
        for i in range(n):
            res = max(res, Cnt(i))

        return res

同樣是計數，我們會想到用兩個指標l,r分別記錄左右括號的數量 ；如果 r > l ，說明上次可以匹配的括號到當前的括號這一段不能匹配，重置 l 和 r 為 0；如果 r== l, 此時可以匹配，更新res

class Solution:
    def longestValidParentheses(self, s: str) -> int:
        l=r=res=0
        for i in s:
            if i=='(':
                l+=1
            else:
                r+=1
            if l==r:
                res=max(res,l+r)
            if r>l:
                l=r=0

        #針對((((()這種情況逆序遍歷一遍
        l=r=0
        for i in s[::-1]:
            if i=='(':
                l+=1
            else:
                r+=1
            if l==r:
                res=max(res,l+r)
            if r<l:
                l=r=0 

        return res

dp

猜到可以dp，想不出，看別人思路寫出來

（圖片來自網路）

class Solution:
    def longestValidParentheses(self, s: str) -> int:
        res = 0
        dp = [0] * (len(s) + 1)
        for i in range(1, len(s) + 1):
            if s[i - 1] == '(':
                continue
            left = i - 2 - dp[i - 1]
            if left >= 0 and s[left] == '(':
                dp[i] = dp[i - 1] + 2
                if dp[i - dp[i]]:
                    dp[i] += dp[i - dp[i]]  
                res =max(res,dp[i])

        return res