LeetCode 刷题记录 32. Longest Valid Parentheses

最新推荐文章于 2022-09-01 00:56:47 发布
最新推荐文章于 2022-09-01 00:56:47 发布
阅读量92 收藏
点赞数
分类专栏： LeetCode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dldldl1994/article/details/99610938
版权

Given a string containing just the characters ‘(’ and ‘)’, find the length of the longest valid (well-formed) parentheses substring.

Example 1:

Input: “(()”
Output: 2
Explanation: The longest valid parentheses substring is “()”
Example 2:

Input: “)()())”
Output: 4
Explanation: The longest valid parentheses substring is “()()”

解法1：
用栈解决
假设有字符串 “) ( ) ( ) ) ( ( ( ( ) ) ) (”
start代表有效括号开始的位置，初始化为-1
遍历字符串
第一个是 ） 栈为空，此时无有效的（与它匹配，故将start的值变为i = 0
第二个是 ( 将i值入栈，此时栈： 1
第三个是 ） 栈不为空，说明有有效的（与它匹配，将左括号退栈，此时栈为空，将匹配的左括号退栈后再次检查栈是否为空
为空 ：说明此时没有多余的（阻断有效的括号，我们可以通过 i - start来计算长度，此时为2 - 0 = 2，更新最大长度2
第四个是 ( 将i值入栈，此时栈： 3
第五个是 ） 栈不为空，说明有有效的（与它匹配，将左括号退栈，此时栈为空，将匹配的左括号退栈后再次检查栈是否为空
为空 ：说明此时没有多余的（阻断有效的括号，我们可以通过 i - start来计算长度，此时为4 - 0 = 2，更新最大长度4
第六个是 ） 栈为空，此时无有效的（与它匹配，说明有非法的）阻断有效的字符串，故将start的值变为i = 5
7、8、9都是（，入栈，此时栈：6，7, 8
第十个是 ） 栈不为空，说明有有效的（与它匹配，将左括号退栈，此时栈为空，将匹配的左括号退栈后再次检查栈是否为空
此时栈：6,7，栈不为空，此时有多余的（阻断有效括号，我们不能用i - start来计算长度，应该用 i - st.top()，即9 -7 = 2，更新最大长度4
第十一个是 ） 栈不为空，说明有有效的（与它匹配，将左括号退栈，此时栈为空，将匹配的左括号退栈后再次检查栈是否为空
此时栈：6，栈不为空，此时有多余的（阻断有效括号，我们不能用i - start来计算长度，应该用 i - st.top()，即10 -6 = 4，更新最大长度4
第十二个是 ( 将i值入栈，此时栈： 6,11
结束算法

c++：

class Solution {
public:
    int longestValidParentheses(string s) {
        stack<int> st;
        int maxLen = 0;
        int start = -1;
        int n = s.size();
        for(int i = 0; i < n; i++){
            if(s[i] == '('){
                st.push(i);
            } else {
                if(st.empty()){
                    start = i;
                } else{
                    st.pop();
                    if(st.empty()){
                        maxLen = max(maxLen, i - start);
                    } else {
                        maxLen = max(maxLen, i - st.top());
                    }
                }
                
            }
        }
        return maxLen;
    }
};

java：

class Solution {
    public int longestValidParentheses(String s) {
        Stack<Integer> st = new Stack<>();
        int maxLen = 0;
        int start = -1;
        int n = s.length();
        for(int i = 0; i < n; i++){
            if(s.charAt(i) == '('){
                st.push(i);
            } else {
                if(st.empty()){
                    start = i;
                } else{
                    st.pop();
                    if(st.empty()){
                        maxLen = Math.max(maxLen, i - start);
                    } else {
                        maxLen = Math.max(maxLen, i - st.peek());
                    }
                    
                }
                
            }
        }
        return maxLen;
    }
}

python:

class Solution(object):
    def longestValidParentheses(self, s):
        """
        :type s: str
        :rtype: int
        """
        st = []
        maxLen = 0;
        start = -1;
        n = len(s)
        for i in xrange(n):
            if s[i] == '(':
                st.append(i)
            else:
                if not st:
                    start = i
                else:
                    st.pop()
                    if not st:
                        maxLen = max(maxLen, i - start)
                    else:
                        maxLen = max(maxLen, i - st[-1])
                    
                
        return maxLen

解法1的变体：
为了实现两种计算长度的统一， i - st.top()和i - start，我们将要更新start值时将start值压入栈中，这样统一用 i - st.top()就可以了
java：

public class Solution {

    public int longestValidParentheses(String s) {
        int maxLen = 0;
        Stack<Integer> st = new Stack<>();
        st.push(-1);
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '(') {
                st.push(i);
            } else {
                st.pop();
                if (st.empty()) {
                    st.push(i);
                } else {
                    maxLen = Math.max(maxLen, i - st.peek());
                }
            }
        }
        return maxLen;
    }
}

解法1的变体2：
假设有字符串“（））（）（（（））”
首先初始化栈[0]
第一个是（： 是左括号，追加0，此时栈[0,0]
第二个是 )： 是右括号，查看栈中数字的数量，大于1说明有可以匹配的（，取出栈中此时的括号数量，为0，更新括号数量此时栈[2]，更新最大的括号的数量，2
第三个是 )：是右括号，查看栈中数字的数量，为1，说明没有可以匹配的（，说明有不合法的），将栈初始化[0]
第四个是 （：是左括号，追加0，此时栈[0,0]
第五个是 )： 是右括号，查看栈中数字的数量，大于1说明有可以匹配的（，取出栈中此时的括号数量，为0，更新括号数量此时栈[2]，更新最大的括号的数量，2
6,7，8都是（，此时栈[2,0,0,0]
第九个是 )： 是右括号，查看栈中数字的数量，大于1说明有可以匹配的（，取出栈中此时的括号数量，为0，更新括号数量此时栈[2,0,2]，更新最大的括号的数量，2
第十个是 )： 是右括号，查看栈中数字的数量，大于1说明有可以匹配的（，取出栈中此时的括号数量，为2，更新括号数量此时栈[2,4]，更新最大的括号的数量，4

python:

class Solution(object):
    def longestValidParentheses(self, s):
        """
        :type s: str
        :rtype: int
        """
        st = [0]
        maxLen = 0
        for c in s:
            if c == '(':
                st.append(0)
            else:
                if len(st) > 1:
                    val = st[-1]
                    st.pop()
                    st[-1] += val + 2
                    maxLen = max(st[-1], maxLen)
                    
                   
                else:
                    st = [0]
                    
                
        return maxLen

解法2：
DP：
dp[i]表示为在位置i结尾的的有效括号长度
由定义知所有（的位置dp值都为0，因为以（结尾的都不是有效括号
在程序中我们只需处理）的dp值
假设有字符串“（））（）（（））”
从第二个开始
第二个是），i-1 的字符是（，说明匹配成功个数在dp[i-2]的基础上增加了2，dp数组[0,2,0,0,0,0,0,0,0]，更新最大长度2
第三个是），i-1的字符不是（，这时候可能匹配的（可能在前边，已知dp[i-1]的值为x，说明位置i-1结尾的的有效括号长度为x，所以我们要越过x个位置去找匹配的（，具体来说就是位置i - dp[i-1] - 1，此时匹配的（不存在， dp数组[0,2,0,0,0,0,0,0,0]，更新最大长度2
第四个是（，不做处理，dp数组[0,2,0,0,0,0,0,0,0]
第五个是），i-1 的字符是（，说明匹配成功个数在dp[i-2]的基础上增加了2，dp数组[0,2,0,2,0,0,0,0,0]，更新最大长度2
第六个是（，不做处理，dp数组[0,2,0,2,0,0,0,0,0]
第七个是（，不做处理，dp数组[0,2,0,2,0,0,0,0,0]
第八个是），i-1 的字符是（，说明匹配成功个数在dp[i-2]的基础上增加了2，dp数组[0,2,0,2,0,0,0,2,0]，更新最大长度2
第三个是），i-1的字符不是（，这时候可能匹配的（可能在前边，已知dp[i-1]的值为2，说明位置i-1结尾的的有效括号长度为2，所以我们要越过2个位置去找匹配的（，具体来说就是位置j = i - dp[i-1] - 1 = 8 - 2 - 1 = 5，此时对应的是可以匹配的（，dp[i] = dp[i-1] + 2，此时还要关注前面是否有可以接上的有效括号，即再加上dp[j - 1] ，如此时dp[4] = 2,说明前面有可以接上的2个有效括号， dp数组[0,2,0,0,0,0,0,2,6]，更新最大长度6

注意点：

  1. dp[i] = (i - 2) >= 0 ? dp[i-2] + 2 : 2 最后要加的是2而不是0
  2. dp[i] = dp[i-1] + 2 + ((j - 1) >= 0 ? dp[j - 1] : 0) 注意我们要加的是最后三元表达式的值，所以三元表达式要加括号
    不能写成 dp[i] = dp[i-1] + 2 + (j - 1) >= 0 ? dp[j - 1] : 0 这样会先加dp[i-1] + 2 + (j - 1)的值，然后看是否>=0,然后返回dp[j - 1]或者0
    原因是加减乘除优先级要大于比较

c++：

class Solution {
public:
    int longestValidParentheses(string s) {
        int maxLen = 0;
        int n = s.size();
        vector<int> dp(n, 0);
        for(int i = 1; i < n; i++){
            if(s[i] == ')'){
                if(s[i-1] == '('){
                    dp[i] = (i - 2) >= 0 ? dp[i-2] + 2 : 2;
                } else {
                    int j = i - dp[i-1] - 1;
                    
                    if(j >= 0 && s[j] == '('){
                       
                        
                        dp[i] = dp[i-1] + 2 + ((j - 1) >= 0 ? dp[j - 1] : 0);
                        
                        
                    }
                }
               
                maxLen = max(maxLen, dp[i]);
            } 
        }
        
        return maxLen;
    }
};

java:

class Solution {
    public int longestValidParentheses(String s) {
        int maxLen = 0;
        int n = s.length();
        int[] dp = new int[n];
        for(int i = 1; i < n; i++){
            if(s.charAt(i) == ')'){
                if(s.charAt(i-1) == '('){
                    dp[i] = (i - 2) >= 0 ? dp[i-2] + 2 : 2;
                    
                } else {
                    int j = i - dp[i-1] - 1;
                    
                    if(j >= 0 && s.charAt(j) == '('){
                       
                        
                        dp[i] = dp[i-1] + 2 + ((j - 1) >= 0 ? dp[j - 1] : 0);
                        
                        
                    }
                }
               
                maxLen = Math.max(maxLen, dp[i]);
            } 
        }
        
        return maxLen;
    }
}

python:
注意点：dp[i] = dp[i-1] + 2 + (dp[j - 1] if (j - 1) >= 0 else 0) 必须在后边加括号，否则它的意思为 if (j - 1) >= 0 dp[i] = dp[i-1] + 2 + (dp[j - 1] 否则dp[i] = 0

class Solution(object):
    def longestValidParentheses(self, s):
        """
        :type s: str
        :rtype: int
        """
        n = len(s)
        dp = [0] * n
        maxLen = 0;
       
        for i in xrange(1, n):
            if s[i] == ')':
                if s[i-1] == '(':
    
                    dp[i] = dp[i-2] + 2 if (i - 2) >= 0 else 2
                    
                else:
                    j = i - dp[i-1] - 1
                    
                    if j >= 0 and s[j] == '(':
                       
                        
                        dp[i] = dp[i-1] + 2 + (dp[j - 1] if (j - 1) >= 0 else 0)
                       
                        
                        
                    
                
               
                maxLen = max(maxLen, dp[i])
             
        
        
        return maxLen;

解法三：两遍扫描法
这种方法不需要额外的空间
设置两个变量left和right，分别代表（和）的数量
首先先正向扫描，从左到右，分别记录（和）的数量，如果left = right 说明是有效字符串，记录它的数量left * 2，更新最大数量
如果）的数量大于（的数量，说明出现非法括号，（和）的数量置0
仅仅正向扫描还是不够的
如“（）（（（））”有效括号为4，正向扫描只能得到2
首先先正向扫描，从左到右，分别记录（和）的数量，如果left = right 说明是有效字符串，记录它的数量left * 2，更新最大数量
如果（的数量大于）的数量，说明出现非法括号，（和）的数量置0
如“（）（（（））”有效括号为4，经过正向反向扫描得到正确的答案4
C++：

class Solution {
public:
    int longestValidParentheses(string s) {
        int maxLen = 0;
        int n = s.size();
        int left = 0,right = 0;
        for(int i = 0; i < n; i++){
            if(s[i] == '('){
                left++;
            } else {
                right++;
            }
            if(left == right){
                maxLen = max(maxLen, 2 * right);
            } else if(right > left){
                left = right = 0;
            }
        }
        left = right = 0;
        for(int i = n-1; i >= 0; i--){
            if(s[i] == '('){
                left++;
            } else {
                right++;
            }
            if(left == right){
                maxLen = max(maxLen, 2 * right);
            } else if(left > right){
                left = right = 0;
            }
        }
        
        return maxLen;
    }
};

java：

class Solution {
    public int longestValidParentheses(String s) {
        int maxLen = 0;
        int n = s.length();
        int left = 0,right = 0;
        for(int i = 0; i < n; i++){
            if(s.charAt(i) == '('){
                left++;
            } else {
                right++;
            }
            if(left == right){
                maxLen = Math.max(maxLen, 2 * right);
            } else if(right > left){
                left = right = 0;
            }
        }
        left = right = 0;
        for(int i = n-1; i >= 0; i--){
            if(s.charAt(i) == '('){
                left++;
            } else {
                right++;
            }
            if(left == right){
                maxLen = Math.max(maxLen, 2 * right);
            } else if(left > right){
                left = right = 0;
            }
        }
        
        return maxLen;
    }
}

python：

class Solution(object):
    def longestValidParentheses(self, s):
        """
        :type s: str
        :rtype: int
        """
        maxLen, n , left , right = 0, len(s), 0, 0
       
        for c in s:
            if c == '(':
                left += 1
            else:
                right += 1
            
            if left == right:
                maxLen = max(maxLen, 2 * right)
            elif right > left:
                left = right = 0
            
        
        left = right = 0;
        for c in s[::-1]:
            if c == '(':
                left += 1
            else:
                right += 1
            
            if left == right:
                maxLen = max(maxLen, 2 * right)
            elif left > right:
                left = right = 0
        
        return maxLen;
dldldl1994
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【LeetCode】解题32：Longest Valid Parentheses（多解法：栈+动态规划+计数器）
Fayedily的博客
04-27 220
LeetCode解题 32：Longest Valid Parentheses（多解法：栈+动态规划+计数器）Problem 32: Longest Valid Parentheses [Hard]解题思路1. 栈2. 动态规划3. 计数器Solution (Java) Problem 32: Longest Valid Parentheses [Hard] Given a string cont...
leetcode每日一题之32. Longest Valid Parentheses
MisterDo的博客
04-08 94
题目描述：最长有效括号 给定一个只包含(和)的字符串，找出最长的包含有效的子串的长度。 示例1： Input:        “(()” Output:        2 示例2： Input:     &nbs...
LeetCode 32. Longest Valid Parentheses
codeman_cdb的专栏
09-01 1060
动态规划，求最长的合法括号的长度
LeetCode：32. Longest Valid Parentheses - Python
Growth Diary
07-09 1942
问题描述：最长有效括号给定一个只包含 '(' 和 ')' 的字符串，找出最长的包含有效括号的子串的长度。示例 1:输入: "(()" 输出: 2 解释: 最长有效括号子串为 "()" 示例 2:输入: ")()())" 输出: 4 解释: 最长有效括号子串为 "()()"问题分析：看到这个问题的时候，第一想法就是那个最长回文子串问题，也就是可以使用动态规划的思想来解决。大概过程如下:（1）设 dp...
Leetcode 32. Longest Valid Parentheses 最长有效括号
CoderWangSon
03-18 230
Leetcode 32. Longest Valid Parentheses 最长有效括号 标签： Leetcode 题目地址： https://leetcode-cn.com/problems/longest-valid-parentheses/ 题目描述 给定一个只包含 '(' 和 ')' 的字符串，找出最长的包含有效括号的子串的长度。 示例 1: 输入: "(...
LeetCode 32. Longest Valid Parentheses(最长有效括号)
Dby_freedom的博客
09-28 247
原题 Given a string containing just the characters ‘(’ and ‘)’, find the length of the longest valid (well-formed) parentheses substring. 题目： 给定一个只包含字符 “(’ 和 ')” 的字符串, 查找最长的有效 (格式正确) 圆括号子字符串的长度。 Example...
Leetcode刷题记——32. Longest Valid Parentheses(最长有效括号)
爱胡椒的小白兔呢
12-27 583
一、题目叙述： Given a string containing just the characters '(' and ')', find the length of the longest valid (well-formed) parentheses substring. For "(()", the long
32. Longest Valid Parentheses
猫敷雪
01-16 382
题目描述（困难难度） 给你一个只包含 '(' 和 ')' 的字符串，找出最长有效（格式正确且连续）括号子串的长度。 给一个一堆括号的字符串，然后返回最长的合法的括号的长度。关于括号的问题，我们在 20 题和 22 题也讨论过。 解法一 暴力解法 列举所有的字符串，然后判断每个字符串是不是符合。当然这里可以做个优化就是，因为合法字符串一定是偶数个，所以可以只列举偶数长度的字符串。列举从 0 开始的，长度是 2、4、6 ……的字符串，列举下标从 1 开始的，长度是 2、4、6 ……的字符串，然后循环下去。当然
[LeetCode] 32. Longest Valid Parentheses @ python
tmfighting的博客
08-06 165
一．题目： 找出一个只包含"(“和”)"的字符串中最长的有效子字符串的长度。有效的意思是指该子字符串中的括号都能正确匹配。 Example 1: Input: "(()" Output: 2 Explanation: The longest valid parentheses substring is "()" Example 2: Input: ")()())" Output: 4 Expla...
LeetCode 刷题汇总1
08-03
LeetCode刷题汇总1 LeetCode刷题汇总1是LeetCode平台上的一系列算法题目汇总，涵盖了各种难度级别的题目，从简单到困难。以下是从这个汇总中提取的知识点： 1. 数组和链表操作： * 两数之和（Two Sum）：给定一个...
程序员面试宝典LeetCode刷题手册
最新发布
05-18
第四章 Leetcode 题解 ...20. Valid Parentheses 21. Merge Two Sorted Lists 22. Generate Parentheses 23. Merge k Sorted Lists 24. Swap Nodes in Pairs 25. Reverse Nodes in k-Group 26. Remove Dupli
leetcode中国-leetcode:leetcode刷题
06-29
我自己的leetcode刷题记录 ###[20150920] Valid Palindrome Implement strStr() String to Integer (atoi) addBinary longestPalindrome maximal rectangle :dp问题，较难 largestRectangleArea 求直方图的最大面积...
Leetcode:LeetCode 刷题总结
05-11
例如，"有效的括号"（Valid Parentheses）要求检查一个字符串是否是有效的小括号序列。 4. **二叉树**：二叉树题目涉及到遍历、搜索、构造、平衡等问题。例如，"二叉树的最大路径和"（Maximum Path Sum）要求找到从...
LeetCode题解（java语言实现）.pdf
04-22
* Valid Parentheses：该题目要求检查括号是否匹配，实现方法使用了栈的数据结构。 * Implement strStr()：该题目要求实现字符串查找算法，实现方法使用了Knuth-Morris-Pratt算法。 四、搜索和排序 * Search ...
LeetCode 刷题记录 7. Reverse Integer
dldldl1994的博客
04-16 4888
Given a 32-bit signed integer, reverse digits of an integer. Example 1: Input: 123 Output: 321 Example 2: Input: -123 Output: -321 Example 3: Input: 120 Output: 21 Note: Assume we are dealing with an ...
LeetCode 刷题记录 8. String to Integer (atoi)
dldldl1994的博客
04-18 430
Implement atoi which converts a string to an integer. The function first discards as many whitespace characters as necessary until the first non-whitespace character is found. Then, starting from this...
LeetCode 刷题记录 95. Unique Binary Search Trees II
dldldl1994的博客
01-13 254
题目： Given an integer n, generate all structurally unique BST’s (binary search trees) that store values 1 … n. Example: Input: 3 Output: [ [1,null,3,2], [3,2,null,1], [3,1,null,null,2], [2,1,3], [1,nul...
LeetCode 刷题记录 50. Pow(x, n)
dldldl1994的博客
10-05 193
题目： Implement pow(x, n), which calculates x raised to the power n (xn). Example 1: Input: 2.00000, 10 Output: 1024.00000 Example 2: Input: 2.10000, 3 Output: 9.26100 Example 3: Input: 2.00000, -2 Outp...
leetcode刷题记录，包含代码和思路讲解，非常详细
07-28
leetcode刷题记录，包含代码和思路讲解，非常详细

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值