[LeetCode] 32. Longest Valid Parentheses

Longest Valid Parentheses

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：栈

重点在于用一个栈来保存左括号的下标。
初始化长度length=0，起始合法位置start=0;
遍历字符串，当遇到左括号时直接将下标压栈，
当遇到右括号时，此时需要判断栈是否为空，

1. 如果为空，说明此时右括号已经多于左括号，不合法，所以将start设置为start = i+1;如果一直不合法，start会一直往后移，直到遇到左括号。
2. 如果不为空，说明此时左括号多于右括号，先将栈顶弹出，再判断栈是否为空：
   2.1 如果为空，更新length为max(length, i-start+1);
   2.2 如果不为空，更新length为max(length, i-st.top());

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

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

解法2：动态规划

初始化一个数组全为0；表示当前字符之前的最长合法长度。
当遍历到左括号‘（’时，标记为0
当遍历到右括号时，即s[i] = ‘)’：
if s[i-1] == ‘(’，当前情况为**…(),判断 i 是否大于等于2，dp[i] = dp[i-2]+2;
if s[i-1]==’)’, 当前情况为…))**,如果此时i-dp[i-1]-1 >=0 && s[i-dp[i-1]-1]==’(’，
再判断已有的合法字符前面还存不存在，即i-dp[i-1]-2 >=0
如果i-dp[i-1]-2 >=0 dp[i] = dp[i-1] + dp[i-dp[i-1]-2] + 2;
否则dp[i] = dp[i-1] + 2;

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

解法3：不用额外空间

定义两个数left和right分别表示当前遍历的左右括号个数，当左右括号个数相等时，求出当前长度
当从左往右时，right>left时，left=right=0
当从右往左时，left>right时，left=right=0；

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

参考

http://www.cnblogs.com/grandyang/p/4424731.html
https://leetcode.com/problems/longest-valid-parentheses/solution/