golang力扣leetcode 32.最长有效括号

简介: golang力扣leetcode 32.最长有效括号

32.最长有效括号

32.最长有效括号

题解

题目:求匹配括号的最长长度

思路一 栈

遍历字符串
1.如果是(,则入栈
2.如果是),如果栈空,说明这个右括号是多于的,将对应的mark置1
     如果栈不空,则弹出栈顶
3.遍历栈,如果栈里还有没有被弹出的(,将对应的mark置1
4.计算连续0的长度,即计算最长可用长度

思路二 dp

dp[i]表示以s[i]字符结尾的最长有效长度

如果s[i]== (

  • 左括号不能与前面的元素匹配,所以dp[i]=0

如果s[i]== )

  • 如果s[i-1]== (
  • 说明构成了()的形式,那么有效长度增加2,即dp[i]=dp[i-2]+2
  • 如果s[i-1]== )
  • 说明构成了xxx ))的形式,这个时候想要形成(())的形式,需要要求s[i-1]的位置是匹配的,如果s[i-1]不匹配,s[i]则不能与前面的(匹配
  • 所以判断s[ i-1-dp[i-1] ] 是否为(

如果s[ i-1-dp[i-1] ]== ( ,说明 i-1-dp[i-1]的左括号和i的右括号匹配,则dp[i]=dp[i-2]+2

但是这里只是考虑了(())的情况,如果是()(())的情况呢?前面的()的长度我们也要加上,所以dp[i] = dp[i-1] + 2 + dp[i-2-dp[i-1]]

综上所述,dp的状态转移方程为

dp[i] = dp[i-2] + 2 //xxxx()
dp[i] = dp[i-1] + 2 + dp[i-2-dp[i-1]] //()(())

思路三 贪心 遍历两次

我们知道有效括号代表这能够匹配,那么

  1. 遇到(,left++ 遇到) right++
  2. 如果left=right,说明匹配成功
  3. 如果left<right,这个情况的前面相等时的长度已经记录过了,直接将left和right置为0
  4. 但是(()这种情况,将没有答案
  5. 这个时候倒着再遍历一遍,将第三步改为如果left>right即可

代码

func longestValidParentheses(s string) int {
  mark := make([]int, len(s))
  stack := make([]int, 0)
  for i, ch := range s {
    if ch == '(' { //如果是(,则入栈
      stack = append(stack, i)
    }
    if ch == ')' { //如果是)
      if len(stack) == 0 { //如果是多余的),说明该位置不可用
        mark[i] = 1
      } else {
        stack = stack[:len(stack)-1] //不是多余的,则弹出一个(
      }
    }
  }
  for _, idx := range stack { //还在栈里面没有被匹配的(,都不可用
    mark[idx] = 1
  }
  ans, temp := 0, 0
  for i := 0; i < len(mark); i++ { //计算最长可用长度
    if mark[i] == 1 {
      temp = 0
    } else {
      temp++
      ans = max(ans, temp)
    }
  }
  return ans
}
func max(i, j int) int {
  if i > j {
    return i
  }
  return j
}
func longestValidParentheses(s string) int {
  ans := 0
  dp := make([]int, len(s))
  for i := 1; i < len(s); i++ {
    ch := s[i]
    if ch == '(' {
      dp[i] = 0
    } else if ch == ')' {
      if s[i-1] == '(' {
        if i-2 >= 0 {
          dp[i] = dp[i-2] + 2 //xxxx()
        } else {
          dp[i] = 2 //()
        }
      } else if s[i-1] == ')' {
        if i-1-dp[i-1] >= 0 && s[i-1-dp[i-1]] == '(' {
          if i-2-dp[i-1] >= 0 {
            dp[i] = dp[i-1] + 2 + dp[i-2-dp[i-1]] //()(())
          } else {
            dp[i] = dp[i-1] + 2 //(())
          }
        }
      }
    }
    ans = max(ans, dp[i])
  }
  return ans
}
func max(i, j int) int {
  if i > j {
    return i
  }
  return j
}
func longestValidParentheses(s string) int {
  left, right := 0, 0
  ans := 0
  for _, v := range s {
    if v == '(' {
      left++
    } else {
      right++
    }
    if left == right {
      ans = max(ans, left+right)
    }
    if right > left {
      left, right = 0, 0
    }
  }
  left, right = 0, 0
  for i := len(s) - 1; i >= 0; i-- {
    v := s[i]
    if v == '(' {
      left++
    } else {
      right++
    }
    if left == right {
      ans = max(ans, left+right)
    }
    if left > right {
      left, right = 0, 0
    }
  }
  return ans
}
func max(i, j int) int {
  if i > j {
    return i
  }
  return j
}


目录
相关文章
|
5月前
|
Go
【LeetCode 热题100】DP 实战进阶:最长递增子序列、乘积最大子数组、分割等和子集(力扣300 / 152/ 416 )(Go语言版)
本文深入解析三道经典的动态规划问题:**最长递增子序列(LIS)**、**乘积最大子数组** 和 **分割等和子集**。 - **300. LIS** 通过 `dp[i]` 表示以第 `i` 个元素结尾的最长递增子序列长度,支持 O(n²) 动态规划与 O(n log n) 的二分优化。 - **152. 乘积最大子数组** 利用正负数特性,同时维护最大值与最小值的状态转移方程。 - **416. 分割等和子集** 转化为 0-1 背包问题,通过布尔型 DP 实现子集和判断。 总结对比了三题的状态定义与解法技巧,并延伸至相关变种问题,助你掌握动态规划的核心思想与灵活应用!
224 1
|
5月前
|
分布式计算 算法 Go
【LeetCode 热题100】BFS/DFS 实战:岛屿数量 & 腐烂的橘子(力扣200 / 994 )(Go语言版)
本文讲解了两道经典的图论问题:**岛屿数量(LeetCode 200)** 和 **腐烂的橘子(LeetCode 994)**,分别通过 DFS/BFS 实现。在“岛屿数量”中,利用深度或广度优先搜索遍历二维网格,标记连通陆地并计数;“腐烂的橘子”则采用多源 BFS,模拟腐烂传播过程,计算最短时间。两者均需掌握访问标记技巧,是学习网格搜索算法的绝佳实践。
218 1
|
5月前
|
Go
【LeetCode 热题100】BFS/DFS 实战:岛屿数量 & 腐烂的橘子(力扣200 / 994 )(Go语言版)
本篇博客详细解析了三道经典的动态规划问题:198. 打家劫舍(线性状态转移)、279. 完全平方数与322. 零钱兑换(完全背包问题)。通过 Go 语言实现,帮助读者掌握动态规划的核心思想及其实战技巧。从状态定义到转移方程,逐步剖析每道题的解法,并总结其异同点,助力解决更复杂的 DP 问题。适合初学者深入理解动态规划的应用场景和优化方法。
163 0
|
5月前
|
算法 Go 索引
【LeetCode 热题100】回溯:括号生成 & 组合总和(力扣22 / 39 )(Go语言版)
本文深入解析了LeetCode上的两道经典回溯算法题:**22. 括号生成**与**39. 组合总和**。括号生成通过维护左右括号数量,确保路径合法并构造有效组合;组合总和则允许元素重复选择,利用剪枝优化搜索空间以找到所有满足目标和的组合。两者均需明确路径、选择列表及结束条件,同时合理运用剪枝策略提升效率。文章附有Go语言实现代码,助你掌握回溯算法的核心思想。
197 0
|
Unix Shell Linux
LeetCode刷题 Shell编程四则 | 194. 转置文件 192. 统计词频 193. 有效电话号码 195. 第十行
本文提供了几个Linux shell脚本编程问题的解决方案,包括转置文件内容、统计词频、验证有效电话号码和提取文件的第十行,每个问题都给出了至少一种实现方法。
241 6
LeetCode刷题 Shell编程四则 | 194. 转置文件 192. 统计词频 193. 有效电话号码 195. 第十行
|
Python
【Leetcode刷题Python】剑指 Offer 32 - III. 从上到下打印二叉树 III
本文介绍了两种Python实现方法,用于按照之字形顺序打印二叉树的层次遍历结果,实现了在奇数层正序、偶数层反序打印节点的功能。
164 6
|
搜索推荐 索引 Python
【Leetcode刷题Python】牛客. 数组中未出现的最小正整数
本文介绍了牛客网题目"数组中未出现的最小正整数"的解法,提供了一种满足O(n)时间复杂度和O(1)空间复杂度要求的原地排序算法,并给出了Python实现代码。
347 2
|
数据采集 负载均衡 安全
LeetCode刷题 多线程编程九则 | 1188. 设计有限阻塞队列 1242. 多线程网页爬虫 1279. 红绿灯路口
本文提供了多个多线程编程问题的解决方案,包括设计有限阻塞队列、多线程网页爬虫、红绿灯路口等,每个问题都给出了至少一种实现方法,涵盖了互斥锁、条件变量、信号量等线程同步机制的使用。
245 3
LeetCode刷题 多线程编程九则 | 1188. 设计有限阻塞队列 1242. 多线程网页爬虫 1279. 红绿灯路口
|
机器学习/深度学习 人工智能 自然语言处理
280页PDF,全方位评估OpenAI o1,Leetcode刷题准确率竟这么高
【10月更文挑战第24天】近年来,OpenAI的o1模型在大型语言模型(LLMs)中脱颖而出,展现出卓越的推理能力和知识整合能力。基于Transformer架构,o1模型采用了链式思维和强化学习等先进技术,显著提升了其在编程竞赛、医学影像报告生成、数学问题解决、自然语言推理和芯片设计等领域的表现。本文将全面评估o1模型的性能及其对AI研究和应用的潜在影响。
324 1
|
索引 Python
【Leetcode刷题Python】从列表list中创建一颗二叉树
本文介绍了如何使用Python递归函数从列表中创建二叉树,其中每个节点的左右子节点索引分别是当前节点索引的2倍加1和2倍加2。
325 7

热门文章

最新文章

推荐镜像

更多