Gemini永久会员 Java 返回最长有效子串长度

Java 返回最长有效子串长度

要返回字符串中最长的有效括号子串的长度，可以使用动态规划或栈的方法。以下是两种实现方式：

方法一：动态规划

java 复制代码

public int longestValidParentheses(String s) {
    int maxLen = 0;
    int[] dp = new int[s.length()];
    
    for (int i = 1; i < s.length(); i++) {
        if (s.charAt(i) == ')') {
            if (s.charAt(i - 1) == '(') {
                dp[i] = (i >= 2 ? dp[i - 2] : 0) + 2;
            } else {
                int prev = i - dp[i - 1] - 1;
                if (prev >= 0 && s.charAt(prev) == '(') {
                    dp[i] = dp[i - 1] + 2 + (prev > 0 ? dp[prev - 1] : 0);
                }
            }
            maxLen = Math.max(maxLen, dp[i]);
        }
    }
    
    return maxLen;
}

方法二：栈

java 复制代码

public int longestValidParentheses(String s) {
    int maxLen = 0;
    Stack<Integer> stack = new Stack<>();
    stack.push(-1); // 初始化栈底元素
    
    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 {
                maxLen = Math.max(maxLen, i - stack.peek());
            }
        }
    }
    
    return maxLen;
}

方法三：双向遍历（最优空间复杂度）

java 复制代码

public int longestValidParentheses(String s) {
    int left = 0, right = 0, maxLen = 0;
    
    // 从左到右遍历
    for (int i = 0; i < s.length(); i++) {
        if (s.charAt(i) == '(') left++;
        else right++;
        
        if (left == right) {
            maxLen = Math.max(maxLen, 2 * right);
        } else if (right > left) {
            left = right = 0;
        }
    }
    
    left = right = 0;
    // 从右到左遍历
    for (int i = s.length() - 1; i >= 0; i--) {
        if (s.charAt(i) == '(') left++;
        else right++;
        
        if (left == right) {
            maxLen = Math.max(maxLen, 2 * left);
        } else if (left > right) {
            left = right = 0;
        }
    }
    
    return maxLen;
}

使用示例

java 复制代码

public static void main(String[] args) {
    Solution solution = new Solution();
    System.out.println(solution.longestValidParentheses("(()")); // 输出: 2
    System.out.println(solution.longestValidParentheses(")()())")); // 输出: 4
    System.out.println(solution.longestValidParentheses("")); // 输出: 0
}

这些方法都能有效找到最长有效括号子串的长度，时间复杂度都是O(n)，空间复杂度从O(n)（动态规划和栈）到O(1)（双向遍历）不等。