【一篇文章学会使用从暴力法=＞记忆化搜索=＞动态规划以及栈的多种方法来实现LeetCode 32题最长有效括号问题】

🚀 算法题 🚀

🌲 算法刷题专栏 | 面试必备算法 | 面试高频算法 🍀
🌲 越难的东西,越要努力坚持，因为它具有很高的价值，算法就是这样✨
🌲 作者简介：硕风和炜，优快云-Java领域新星创作者🏆，保研|国家奖学金|高中学习JAVA|大学完善JAVA开发技术栈|面试刷题|面经八股文|经验分享|好用的网站工具分享💎💎💎
🌲 恭喜你发现一枚宝藏博主,赶快收入囊中吧🌻
🌲 人生如棋，我愿为卒，行动虽慢，可谁曾见我后退一步？🎯🎯

🚀 算法题 🚀

🚩 题目链接

• 32. 最长有效括号

⛲ 题目描述

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

示例 1：

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

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

输入：s = “”
输出：0

提示：

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

🌟 求解思路&实现代码&运行结果

---

⚡ 暴力法

🥦 求解思路

1. 暴力法比较简单，我们枚举以每一个下标为开始位置，分别找到有效的（格式正确且连续）括号子串，找到所有情况的最大值即可。
2. 问题来了？怎么找到以每一个位置为开始位置的最长连续有效子串呢？
3. 我们可以来做一个简单的分析， 如果此时我们枚举到以cur位置为开始的最长有效的子串，此时的位置字符如果是’)‘,我们直接忽略，因为我们找不到以’)‘位置作为开始位置的有效子串；如果此时位置的字符是’(‘,那么我们有俩种情况可以进行判断，第一种去判断下一个位置的字符是’)‘吗？如果是，那么我们直接从cur+2去调用我们的递归函数，并且直接在原来的结果加2；但是，如果此时下一个位置的字符还是’(‘,那么此时我们就需要先找到以cur+1作为开始位置的最长连续有效子串长度len，然后去判断此时cur+len+1位置的元素是否为’)'，如果是的话，我们直接从cur+len+2去调用我们的递归函数，并且直接在原来的结果加2。
4. 思路我们有了，接下来就是具体代码的实现了。

🥦 实现代码

class Solution {
    public int longestValidParentheses(String s) {
        char[] arr=s.toCharArray();
        int max=0;
        for(int i=0;i<arr.length;i++){
            max=Math.max(max,process(i,arr));
        }
        return max;
    }

    public int process(int index,char[] arr){
        if(index>=arr.length) return 0;
        int max=0;
        if(arr[index]=='('){
            if(index+1<arr.length&&arr[index+1]==')'){
                max=Math.max(max,process(index+2,arr)+2);
            }else if(index+1<arr.length&&arr[index+1]=='('){
                int pre=process(index+1,arr);
                if(pre+index+1<arr.length&&arr[pre+index+1]==')'){
                    max=Math.max(max,pre+process(index+pre+2,arr)+2);
                }
            }
        }
        return max;
    }
}

🥦 运行结果

---

⚡ 记忆化搜索

🥦 求解思路

1. 因为在递归的过程中，会重复的出现一些多次计算的结果，我们通过开辟一个数组，将结果提前缓存下来，算过的直接返回，避免重复计算，通过空间来去换我们的时间。

🥦 实现代码

class Solution {

    private int[] dp;

    public int longestValidParentheses(String s) {
        char[] arr=s.toCharArray();
        dp=new int[arr.length];
        Arrays.fill(dp,-1);
        int max=0;
        for(int i=0;i<arr.length;i++){
            max=Math.max(max,process(i,arr));
        }
        return max;
    }

    public int process(int index,char[] arr){
        if(index>=arr.length) return 0;
        if(dp[index]!=-1) return dp[index];
        int max=0;
        if(arr[index]=='('){
            if(index+1<arr.length&&arr[index+1]==')'){
                max=Math.max(max,process(index+2,arr)+2);
            }else if(index+1<arr.length&&arr[index+1]=='('){
                int pre=process(index+1,arr);
                if(pre+index+1<arr.length&&arr[pre+index+1]==')'){
                    max=Math.max(max,pre+process(index+pre+2,arr)+2);
                }
            }
        }
        return dp[index]=max;
    }
}

🥦 运行结果

我们发现，通过加一个缓存表，时间复杂度发生了翻天覆地的变化，真实不可思议！

---

⚡ 动态规划

🥦 求解思路

1. 有了递归，有了记忆化搜索，接下来就是动态规划了，直接上手。

🥦 实现代码

class Solution {

    private int[] dp;

    public int longestValidParentheses(String s) {
        char[] arr=s.toCharArray();
        int n=arr.length;
        dp=new int[n+10];
        int ans=0;
        for(int index=n-1;index>=0;index--){
            int max=0;
            if(arr[index]=='('){
                if(index+1<arr.length&&arr[index+1]==')'){
                    max=Math.max(max,dp[index+2]+2);
                }else if(index+1<arr.length&&arr[index+1]=='('){
                    int pre=dp[index+1];
                    if(pre+index+1<arr.length&&arr[pre+index+1]==')'){
                        max=Math.max(max,pre+dp[index+pre+2]+2);
                    }
                }
            }
            dp[index]=max;
            ans=Math.max(ans,dp[index]);
        }
        return ans;
    }
}

🥦 运行结果

---

⚡ 栈

🥦 求解思路

已知每个有限的括号字符串必须是连续的，那么可以用栈来寻找以某个字符结尾最长的有限长度。
将栈底保存为最后一个未被匹配的右括号下标。

1. 若当前字符为’(',直接将坐标放入栈中。
2. 若当前字符为’)‘，先弹出栈顶坐标，若弹出后栈顶为空，那么代表这个’)'未被匹配，放入栈中;若栈不为空，那么代表已经匹配了，这时候统计它的有限长度为i-栈顶坐标。

🥦 实现代码

class Solution {
    public int longestValidParentheses(String s) {
        int n = s.length(), ans = 0;
        char[] arr = s.toCharArray();
        Deque<Integer> stack = new ArrayDeque<>();
        stack.push(-1);
        for (int i = 0; i < n; i++) {
            if (arr[i] == '('){
                stack.push(i);
            }
            else {
                stack.pop();
                if (stack.isEmpty()) {
                    stack.push(i);
                } else {
                    ans = Math.max(ans, i - stack.peek());              
                }
            }
        }
        return ans;
    }
}

🥦 运行结果

---

🍋 总结

本文介绍了四种解法来解决 LeetCode 32 题，即最长有效括号问题。循序渐进的引导大家从暴力法=＞记忆化搜索=＞动态规划以及栈的多种方法来实现最长有效括号问题。在实际应用中，可以根据具体情况来选择最合适的方法。

💬 共勉

最后，我想和大家分享一句一直激励我的座右铭，希望可以与大家共勉！