最长有效括号
题目链接：https://leetcode-cn.com/problems/longest-valid-parentheses/
给你一个只包含 '(' 和 ')' 的字符串，找出最长有效（格式正确且连续）括号子串的长度。
示例 1：
输入：s = "(()"
输出：2
解释：最长有效括号子串是 "()"
示例 2：
输入：s = ")()())"
输出：4
解释：最长有效括号子串是 "()()"
示例 3：
输入：s = ""
输出：0
提示：
0 <= s.length <= 3 * 104
s[i] 为 '(' 或 ')'
问题分析：
方案1：动态规划
最值问题，应该是一个最值类的dp问题，考虑拆分子问题，弄清楚子问题和我们要解决的大问题之间的联系
-
前一个子问题的解可以提供给后面的子问题多大的有效长度？(子问题)
-
后一个子问题的解，要想纳入前面提供的有效长度，则前面子串的末尾必须是有效长度的一部分(连续性)
我们设dp[i]代表子问题i的解
即dp[i]：以s[i]结尾的有效子串的最长长度，注意：有效子串必须以s[i]结尾,这样才能将每个子问题关联起来
我们可以分类讨论s[i]是不同字符的情况
-
s[i]是左括号：dp[i]=0，因为左括号结尾必然构不成有效字符串
-
s[i]是右括号：这种情况下，还需要考虑相连的s[i-1]是什么字符
-
s[i-1]是左括号，那么s[i]和s[i-1]刚好匹配，那么dp[i]=dp[i-2]+2
-
s[i-1]是右括号，这种情况下，我们要分析与s[i]匹配的字符s[k]到底是什么字符，k=i-dp[i-1]-1
-
k是右括号，都是右括号，不匹配，跳过
-
k是左括号，匹配，dp[i]=x+2,x其实是两个绿色部分的最长有效括号值相加，即x=dp[i-1]+dp[i-dp[i-1]-2],即此时dp[i]=dp[i-1]+dp[i-dp[i-1]-2]+2
-
-
根据以上分析出的子问题间的关系(即前后元素dp值的关系)，即可求解出所有的子问题的值，最后找出子问题中解中的最大值，即是我们的最长子串的有效长度
时间复杂度：O(N)
空间复杂度：O(N)
func max(a, b int) int {
if a > b {
return a
}
return b
}
func longestValidParentheses(s string) int {
dp := [30005]int{} // dp[i]: 以s[i]结尾的最长有效子串长度
maxDp := 0
for i := 1; i < len(s); i++ {
if s[i] == '(' {
dp[i] = 0
} else {
if s[i-1] == '(' {
// 避免下标越界
if i-2 >= 0 {
dp[i] = dp[i-2] + 2
} else {
dp[i] = 2
}
} else if i-dp[i-1]-1 >= 0 && s[i-1] == ')' {
k := i - dp[i-1] - 1 // 根据k位置字符的不同再次分类讨论
if s[k] == '(' {
var x int
// 避免下标越界
if i-dp[i-1]-2 >= 0 {
x = dp[i-1] + dp[i-dp[i-1]-2]
} else {
x = dp[i-1]
}
dp[i] = x + 2
}
}
}
// 寻找最大的dp值，即是最长有效子串长度
maxDp = max(maxDp, dp[i])
}
return maxDp
}
方法2：利用栈直接统计最长有效长度
始终保持栈底元素为当前已经遍历过的元素中【最后一个没有被匹配的右括号的下标】，栈里其他元素维护左括号的下标
- 遇到每个'('左括号，将其下标放入栈中
- 遇到每个')'右括号,我们先弹出栈顶元素(代表匹配成功),然后再判断
- 如果栈不为空，说明有对应的左括号与之匹配，当前右括号下标减去栈顶元素即为【以该右括号结尾的最长有效括号长度】
- 如果栈为空，我们将其放入栈中，以更新前面提到的【最后一个没有被匹配的右括号的下标】
- 注意：一开始栈为空，如果第一个字符为左括号，那么就不满足【最后一个没有被匹配的右括号的下标】，所以这种情况下，我们一开始向栈中放入一个值为-1的元素
时间复杂度：O(N)
空间复杂度：O(N)
func max(a, b int) int {
if a > b {
return a
}
return b
}
func longestValidParentheses(s string) int {
if len(s)==0{
return 0
}
var st []int
var result int
st=append(st,-1)
for i:=0;i<len(s);i++{
if s[i]=='('{ // 当前值是左括号，入栈
st=append(st,i)
}else {
st=st[:len(st)-1] // 当前值是右括号，弹出栈顶元素
if len(st)==0{ // 栈空了，将当前右括号入栈
st=append(st,i)
}else {
result=max(result,i-st[len(st)-1]) // 栈没空，计算有效连续长度，并记录最大值
}
}
}
return result
}
方法3：利用栈直接标记出合法括号，然后才统计最大长度
利用栈先入先出的性质，将合法括号置为1，然后统计连续1的最大长度
具体思路：
-
栈记录左括号，遇到右括号就和栈顶的左括号匹配
-
数组flag记录那些括号是已经匹配的，flag[i]=1
-
最后遍历数组，连续最长的1的长度即是最长有效括号
时间复杂度：O(N)
空间复杂度：O(N)
func max(a, b int) int {
if a > b {
return a
}
return b
}
func longestValidParentheses(s string) int {
if len(s)==0{
return 0
}
var stack []int
var flag [30005]int
// 利用栈将合法括号标记为1
for i:=0;i<len(s);i++{
if s[i]=='('{
stack=append(stack,i)
}else {
if len(stack)!=0{
flag[i]=1
flag[stack[len(stack)-1]]=1
stack=stack[:len(stack)-1]
}
}
}
// 统计连续的最长合法括号长度
result:=0
count:=0
for i:=0;i<len(s);i++{
if flag[i]==1{
count++
result=max(result,count)
}else {
count=0
}
}
return result
}
方法四：双向双指针遍历统计
核心：遍历串时，如果串的右括号数量大于左括号数量，那么该串肯定不是合法括号串，因为就算后面再出现了左括号，也无法与前面的右括号配对了
左括号指针：统计左括号数量，left
右括号指针：统计右括号数量，right
采用两个指针，遍历整个大串
- 当right>left，那么left，right重置为0
- 当right==left，记录最大值
- 当right<left，继续遍历统计
但这样会漏掉一种情况，即左括号数量始终都是大于右括号数量的情况，解决方法就是从右往左再遍历一遍，只不过判断条件需要反过来
-
当right<left，那么left，right重置为0
-
当right==left，记录最大值
-
当right>left，继续遍历统计
时间复杂度：O(N)
空间复杂度：O(1)
func max(a, b int) int {
if a > b {
return a
}
return b
}
func longestValidParentheses(s string) int {
if len(s)==0{
return 0
}
result:=0
// 从左往右 统计
left,right:=0,0
for i:=0;i<len(s);i++{
if s[i]=='('{
left++
}else {
right++
}
if left==right{
result=max(result,left+right)
}
if right>left{
left,right=0,0
}
}
// 从右往左 统计
left,right=0,0
for j:=len(s)-1;j>=0;j--{
if s[j]=='('{
left++
}else {
right++
}
if left==right{
result=max(result,left+right)
}
if right<left{
left,right=0,0
}
}
return result
}