算法---LeetCode 32. 最长有效括号

1. 题目

原题链接

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

示例 1：

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

示例 2：

输入：s = “)()())”
输出：4
解释：最长有效括号子串是 “()()”

示例 3：

输入：s = “”
输出：0

提示：

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

Related Topics 字符串 动态规划
👍 1320 👎 0

2. 题解

2.1 解法1: 栈

1. 栈中保存括号的下标, 栈底始终保存 当前已经遍历过的元素中「最后一个没有被匹配的右括号的下标」
2. 两种索引会入栈:
   (1)等待被匹配的左括号索引。
   (2)充当**「参照物」的右括号索引**。因为：当左括号匹配光时，栈需要留一个垫底的参照物，用于计算一段连续的有效长度。

流程:

1. 对于遇到的每个 ‘(’ ，我们将它的下标放入栈中
2. 对于遇到的每个 ‘)’ ，我们先弹出栈顶元素表示匹配了当前右括号：
   (1)如果栈为空，说明当前的右括号为没有被匹配的右括号，我们将其下标放入栈中来更新我们之前提到的「最后一个没有被匹配的右括号的下标」
   (2)如果栈不为空，当前右括号的下标减去栈顶元素即为「以该右括号为结尾的最长有效括号的长度」

注意点: 开始的时候往栈中放入一个值为 -1 的元素,
原因: 如果一开始栈为空，第一个字符为左括号的时候我们会将其放入栈中，这样就不满足提及的「最后一个没有被匹配的右括号的下标」

    class Solution {
        public int longestValidParentheses(String s) {
            Deque<Integer> stack = new LinkedList<>();
            stack.push(-1);
            int ans = 0;
            for (int i = 0; i < s.length(); i++) {
                if (s.charAt(i) == '(') {
                    stack.push(i);
                } else {
                    stack.pop();
                    if (stack.isEmpty()) { // 栈空了, 将该右括号入栈充当参考
                        stack.push(i);
                    } else {
                        ans = Math.max(ans, i - stack.peek()); // 否则通过当前栈底元素计算当前匹配的长度
                    }
                }
            }
            return ans;
        }
    }

2.2 解法2: 动态规划

状态数组: dp[i] 代表以下标 i 位置字符结尾的最长有效括号数

递推方程:

1. s[i]是’(’，以它为结尾的子串，肯定不是有效括号子串——dp[i] = 0

2. s[i]是’)’，以它为结尾的子串，可能是有效子串，还需考察前一个子问题的末尾 s[i-1]

(1) s[i-1]是’(’，s[i-1]和s[i]组成一对，有效长度保底为 2，还需考察s[i-2]：
a. s[i-2]不存在，则有效长度只有 2 —— dp[i] = 2
b. s[i-2]存在，则加上以s[i-2]为结尾的最长有效长度—— dp[i] = dp[i-2] + 2

(2) s[i-1]是’)’，s[i-1]和s[i]就是’))’，以s[i-1]为结尾的最长有效长度为dp[i-1]，跨过这个长度（具体细节不用管，总之它最大能提供dp[i-1]长度），设 lastIndex = i-dp[i-1]-1, 来看s[lastIndex]这个字符, 即与 s[i-1] 相匹配的那个字符：
a. s[lastIndex]不存在或为’)’，则s[i]找不到匹配，直接gg —— dp[i]=0
b. s[lastIndex]是’(’，与s[i]匹配，有效长度 = 2 + 跨过的dp[i-1]+ 前方的dp[lastIndex-1]。等一下，s[lastIndex-1]要存在才行！：
s[lastIndex-1]存在，dp[i] = dp[i-1] + dp[lastIndex-1] + 2
s[lastIndex-1]不存在，dp[i] = dp[i-1] + 2

初始条件和边界情况：

初始条件： dp[i] = 0
边界情况：需要保证计算过程中：i - 2 >= 0 和 i - dp[i - 1] - 2 >= 0

    class Solution {
        public int longestValidParentheses(String s) {
            if (s == null) {
                return 0;
            }
            char[] ss = s.toCharArray();
            int[] dp = new int[ss.length];
            int ans = 0;
            for (int i = 1; i < ss.length; i++) {
                if (ss[i] == ')') {
                    if (ss[i - 1] == '(') {
                        if (i - 2 > 0) {
                            dp[i] = dp[i - 2] + 2;
                        } else {
                            dp[i] = 2;
                        }
                    } else if (dp[i - 1] > 0) {
                        int lastIndex = i - dp[i - 1] - 1;
                        if (lastIndex >= 0 && ss[lastIndex] == '(') {
                            if (lastIndex - 1 >= 0) {
                                dp[i] = dp[i - 1] + 2 + dp[lastIndex - 1];
                            } else {
                                dp[i] = dp[i - 1] + 2;
                            }
                        }
                    }
                }
                ans = Math.max(ans, dp[i]);
            }
            return ans;
        }
    }

参考:
「手画图解」剖析两种解法：利用栈、动态规划 | 32. 最长有效括号
动态规划思路详解（c++）——32.最长有效括号