动态规划的算法题

题目：最长有效括号
给你一个只包含 ‘(’ 和 ‘)’ 的字符串，找出最长有效（格式正确且连续）括号子串的长度。
示例1：输入：s = “(()”
输出：2
解释：最长有效括号子串是 “()”
示例2：输入：s = “)()())”
输出：4
解释：最长有效括号子串是 “()()”
示例 3：输入：s = “”
输出：0
题解：有效括号就是任意一个左括号都有一个右括号与之对应。
其实这道题的暴力硬解就是通过栈来遍历给定字符串的过程中去判断到目前为止扫描的子串的有效性，同时能得到最长有效括号的长度。
具体做法是我们始终保持栈底元素为当前已经遍历过的元素中最后一个没有被匹配的右括号的下标，这样的做法主要是考虑了边界条件的处理，栈里其他元素维护左括号的下标：
对于遇到的每个 ‘(’ ，我们将它的下标放入栈中
对于遇到的每个 ‘)’ ，我们先弹出栈顶元素表示匹配了当前右括号：
①如果栈为空，说明当前的右括号为没有被匹配的右括号，我们将其下标放入栈中来更新我们之前提到的最后一个没有被匹配的右括号的下标。
②如果栈不为空，当前右括号的下标减去栈顶元素即为以该右括号为结尾的最长有效括号的长度。
从前往后遍历字符串并更新答案即可。需要注意的是，如果一开始栈为空，第一个字符为左括号的时候我们会将其放入栈中，这样就不满足提及的最后一个没有被匹配的右括号的下标，为了保持统一，在一开始的时候往栈中放入一个值为 -1−1 的元素。
c++代码

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

c代码

int longestValidParentheses(char* s) {
    int maxans = 0, n = strlen(s);
    int stk[n + 1], top = -1;
    stk[++top] = -1;
    for (int i = 0; i < n; i++) {
        if (s[i] == '(') {
            stk[++top] = i;
        } else {
            --top;
            if (top == -1) {
                stk[++top] = i;
            } else {
                maxans = fmax(maxans, i - stk[top]);
            }
        }
    }
    return maxans;
}

复杂度分析
时间复杂度： O(n)，n 是给定字符串的长度。我们只需要遍历字符串一次即可。
空间复杂度： O(n)。栈的大小在最坏情况下会达到 n，因此空间复杂度为 O(n) 。
解法2就是用动态规划，其实考虑是否用动态规划很经常都是在看到题目里面有个，“最长计数、最大/最小/最长、是否存在”这样的类似词汇。动态规划解法首先要确定状态：①研究最优策略的最后一步②化为子问题；然后是转移方程：可以根据子问题定义得到。再接着就是初始条件和边界情况。最后是计算顺序。
以下是官方对这道题的解答：
我们定义dp[i] 表示以下标 i 字符结尾的最长有效括号的长度。我们将dp 数组全部初始化为 0 。显然有效的子串一定以 ‘)’ 结尾，因此我们可以知道以 ‘(’ 结尾的子串对应的 dp 值必定为 0 ，我们只需要求解 ‘)’ 在 dp 数组中对应位置的值。
我们从前往后遍历字符串求解dp 值，每两个字符检查一次：
当s[i]=‘)’ 且 s[i - 1] =‘(’，也就是字符串形如 “……()”“……()”，我们可以推出：
dp[i]=dp[i−2]+2
我们可以进行这样的转移，是因为结束部分的 “()” 是一个有效子字符串，并且将之前有效子字符串的长度增加了 2 。

当s[i] =‘)’ 且 s[i - 1] = ‘)’，也就是字符串形如 “……))”“……))”，我们可以推出：
如果 s[i - dp[i - 1] - 1] =‘(’，那么
dp[i]=dp[i−1]+dp[i−dp[i−1]−2]+2
考虑如果倒数第二个‘)’ 是一个有效子字符串的一部分（记作 sub_s），对于最后一个‘)’ ，如果它是一个更长子字符串的一部分，那么它一定有一个对应的‘(’ ，且它的位置在倒数第二个‘)’ 所在的有效子字符串的前面（也就是 sub_s的前面）。因此，如果子字符串 sub_s的前面恰好是‘(’ ，那么我们就用 2 加上 subs的长度（dp[i−1]）去更新dp[i]。同时，我们也会把有效子串 “(sub_s)”“(sub_s)” 之前的有效子串的长度也加上，也就是再加上dp[i−dp[i−1]−2]。最后的答案即为dp 数组中的最大值。
c++代码

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;
    }
};

c代码

int longestValidParentheses(char* s) {
    int maxans = 0, n = strlen(s);
    if (n == 0) return 0;
    int dp[n];
    memset(dp, 0, sizeof(dp));
    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 = fmax(maxans, dp[i]);
        }
    }
    return maxans;
}

复杂度分析
时间复杂度：O(n)，其中 n 为字符串的长度。我们只需遍历整个字符串一次，即可将 dp 数组求出来。
空间复杂度：O(n)。我们需要一个大小为 n 的 dp 数组。
题目还有很多，要练习的话我记得是有最小路径和。
因为暴力硬解有时候不是最好的选择，反倒是我觉得这种不算是很难的题目用用动态规划会比较给人看起来有亮点。