题目：https://leetcode-cn.com/problems/longest-valid-parentheses/
给你一个只包含 '(' 和 ')' 的字符串，找出最长有效（格式正确且连续）括号子串的长度。

我的方法一：动态规划

步骤

1. 确认子问题
   1.1 最后一步：加入最后一个字符，连续的子括号或者包括最后这个字符，或者不包括
   1.2 子问题：求去除最后一个字符的子串长度，以及以最后这个字符为结尾的连续子串长度，哪个长，就是当前字符串的最大子串长度；
2. 转移方程
   dp[n] = max(dp[n-1], 以最后一个字符为结尾的连续子串长度)
3. 边界条件和初始条件
   3.1 dp含义，第n个字符为结尾的字符串的最长子串长度，所以n的取值范围是[0, s.size()-1]
   3.2 dp[0] = 0;
   3.3 循环从1开始，至s.size()-1

代码

class Solution {
public:
    int longestValidParentheses(string s) {
        if(s.size() == 0){
            return 0;
        }

        int longest = 0;
        int s_size = s.size();
        const char* s_str = s.c_str();
        stack<char> stck;
        vector<int> longest_mem(s_size, 0);

        int right;
        int sub_longest;
        bool first;
        for(int i=1; i<s_size; i++){
            sub_longest=0;
            right = i;
            first = true;

            while(right>=0){
                if(s_str[right] == '('){
                    if(!stck.empty() && (stck.top() == ')' || stck.top() == '#')){
                        sub_longest++;
                        if(stck.top() == '#' || stck.size() == 1){
                            if(right>0){
                                stck.pop();
                                sub_longest = sub_longest+longest_mem[right-1];
                                break;
                            }
                        }
                        stck.pop();
                    }else{
                        break;
                    }
                }else{
                    if(first){
                        stck.push('#');
                        first = false;
                    }else{
                        stck.push(s_str[right]);
                    }
                }
                right--;
            }

            while(!stck.empty()) {
                if(stck.top() == '#'){
                    sub_longest = 0;
                }
                stck.pop();
            }

            longest_mem[i] = sub_longest;
            if(longest<sub_longest){
                longest=sub_longest;
            }
        }

        return longest*2;
    }
};

代码说明：

1. 使用longest_mem记录以第x个字符为结尾的有效括号长度；
2. 判断括号是否成对，使用栈
3. 最后一个字符在中使用#代替，这样当出现括号不成对停止时，判断下#是否在栈中，如果在说明最后字符没有找到对应的'('，所以有效括号长度是0；
   总体而言，感觉代码有优化的地方。

更好的方法

官方

https://leetcode-cn.com/problems/longest-valid-parentheses/solution/zui-chang-you-xiao-gua-hao-by-leetcode-solution/
它是按照两种情况，思路更加清晰

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