Longest Valid Parentheses

解法1：利用逆序动态规划。dp[i]存储从i到s.size()-1的最长包含i的数，从n-2到1递推即可，且匹配时要考虑把后面的接上

 1 class Solution {
public:
    int longestValidParentheses(string s) {
        int len = s.length();
        if(len<2)
          return 0;
        int max = 0;
        int *dp = new int[len];
        for(int k = 0;k<len;k++)
         dp[k] = 0;
        for(int i = len-2;i>=0;i--)
        {
          if(s[i] == '(')
          {
            int j = i+1+dp[i+1];
            if(j<len && s[j] == ')')
            {
              dp[i] = dp[i+1] + 2;
              if(j+1<len)
                dp[i] += dp[j+1];
            }
            if(dp[i]>max)
              max = dp[i];
          }
          
        }
        return max;
    }
};
解法二：利用stack，存储一个bool数组标记匹配的数组，最后遍历连续的true即可。

class Solution {
public:
    int longestValidParentheses(string s) {
        bool* a=new bool[s.size()];
        memset(a,false,s.size());
        stack<int> st;
        for(int i=0;i<s.size();i++){
            if(s[i]=='(') st.push(i);
            else if(s[i]==')'&&!st.empty()){
                a[i]=true;
                a[st.top()]=true;
                st.pop();
            }
        }
        int cur_num=0;
        int max_num=0;
        for(int i=0;i<s.size();i++){
            if(a[i]==true) 
                cur_num++;
            else 
                cur_num=0;
            max_num=max(cur_num,max_num);
        }
        return max_num;
    }
};