LeetCode 32. 最长有效括号

给你一个只包含 '(' 和 ')' 的字符串，找出最长有效（格式正确且连续）括号子串的长度。

示例 1：

输入：s = "(()"
输出：2
解释：最长有效括号子串是 "()"
示例 2：

输入：s = ")()())"
输出：4
解释：最长有效括号子串是 "()()"
示例 3：

输入：s = ""
输出：0
 

提示：

0 <= s.length <= 3 * 104
s[i] 为 '(' 或 ')'

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-valid-parentheses
 

解法一：

动态规划，dp[i]表示以s[i]结尾的最长有效子串长度。 初始化dp[]数组为0，因为只有当s[i]为‘)’时，dp才可能不为0，如果当s[i-1]为'(',那么dp[i]=dp[i-2]+2；如果当s[i-1]为')',那么只有当s[i-1-dp[i-1]]为‘（’时，dp[i]=dp[i-1]+2+dp[i-2-dp[i-1]]。这个题自己想了很久，但其实还是可以做的。

class Solution {
public:
    int longestValidParentheses(string s) {
        stack<int> st;
        int len= s.length();
        int maxLen=0;
        int l=0;
        vector<int> dp(len);

        for(int i=1;i<len;i++)
        {
            if(s[i]==')')
            {
                if(s[i-1]=='(')
                {
                    dp[i]=2;
                    if(i-2>=0)
                        dp[i]+=dp[i-2];
                }
                else 
                {
                    if(dp[i-1]!=0)
                    {
                        if(i-dp[i-1]-1>=0&&s[i-dp[i-1]-1]=='(')
                        {
                            dp[i]=dp[i-1]+2;
                            if(i-dp[i-1]-2>=0)
                                dp[i]+=dp[i-dp[i-1]-2];
                        }
                    }
                }    
            }
            maxLen=max(maxLen, dp[i]);
        }
        return maxLen;
    }
};

解法二：

利用栈，最暴力的做法是，枚举区间，看区间内括号子串是否有效，但时间复杂度过高。栈底存入最近一个不匹配的右括号的下标。左括号直接入栈，右括号可匹配的话，将栈顶元素出栈，然后长度为当前下标-剩下在栈的栈顶元素。这种做法以前做过，这次也想到用栈，但没想到用栈底存入最近一个不匹配的有括号。受到了难度标签的影响。

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

 解法三：

利用left记录左括号的数量，利用right记录右括号数量。从左往右遍历，当left==right时，为2*left为有效长度，但无法判断‘（（）’的情况。故还需要一次从右往左遍历。这解法也想到了，但没仔细想，还是受到难度标签的影响。

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