leetcode **32. 最長有效括號

【題目】**32. 最長有效括號

給定一個只包含 ‘(’ 和 ‘)’ 的字符串，找出最長的包含有效括號的子串的長度。

示例 1:

輸入: "(()"
輸出: 2
解釋: 最長有效括號子串爲 "()"

示例 2:

輸入: ")()())"
輸出: 4
解釋: 最長有效括號子串爲 "()()"

【解題思路1】暴力法

超時
取<=字符串長度的最小偶數區間遍歷字符串，如果該長度有有小括號那這就是最長長度，如果沒有的話區間長度-2繼續遍歷判斷

class Solution {
    public int longestValidParentheses(String s) {
        int l=s.length()/2*2;
        for(int i=l;i>=2;i-=2){
            for(int j=0;j<=s.length()-i;j++){
                String s1=s.substring(j,j+i);
                if(youxiaokuohao(s1)){return i;}
            }
        }
        return 0;
    }
    public boolean youxiaokuohao(String s1){
        Stack<Integer> stack=new Stack<>();
        for(int i=0;i<s1.length();i++){
            if(s1.charAt(i)=='('){
                stack.push(i);
            }
            else{
                if(stack.isEmpty()){return false;}
                else{stack.pop();}
            }
        }
        return stack.isEmpty();
    }
}

【解題思路2】動態規劃

dp數組的狀態：dp[i]表示以 i 位置結尾的最長有效子字符串的長度，因爲有效括號一定是成對出現的，所以作爲結尾的括號一定是右括號，所以左括號對應的dp[]值一定是0
狀態轉移方程：dp[i] = 2 + dp[i-1] + dp[ i - dp[i-1] - 2 ]

• 判斷 i - dp[i-1] - 1 是否是左括號，如果是則基礎長度爲2
• 加上內部包含的最長有效括號長度是 dp[i-1]
• 加上外部包含的最長有效括號是dp[ i - dp[i-1] - 2 ]
  
  

注意上面的 dp[-1]，是爲了表示 0 位置前面的元素

public class Solution {
    public int longestValidParentheses(String s) {
        int maxans = 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 if (i - dp[i - 1] > 0 && s.charAt(i - dp[i - 1] - 1) == '(') {
                    dp[i] = dp[i - 1] + ((i - dp[i - 1]) >= 2 ? dp[i - dp[i - 1] - 2] : 0) + 2;
                }
                maxans = Math.max(maxans, dp[i]);
            }
        }
        return maxans;
    }
}

【解題思路3】棧

遇到左括號入棧，遇到右括號先出棧然後計算長度
先入棧一個-1，作爲最長子串的第一個分割點


這邊遇到了2位置，-1匹配出棧，棧空，2入棧，作爲新的分割點

public class Solution {
    public int longestValidParentheses(String s) {
        int maxans = 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.empty()) {
                    stack.push(i);
                } else {
                    maxans = Math.max(maxans, i - stack.peek());
                }
            }
        }
        return maxans;
    }
}

【解題思路4】正向逆向結合

記錄左括號個數left、右括號個數right，還有最大子串長度maxlength
從左向右遍歷：

• 當 left = right，更新maxlength = left * 2
• 當 right > left，重置 left = 0, right = 0，說明這個右括號是分割點
  
  如果2位置是左括號，從左往右遍歷到最後，maxlength沒有得到更新，所以還需要從右往左遍歷一遍
• 當 left = right，更新maxlength = left * 2
• 當 left > right，重置 left = 0, right = 0，說明這個左括號是分割點
  

public class Solution {
    public int longestValidParentheses(String s) {
        int left = 0, right = 0, maxlength = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '(') {
                left++;
            } else {
                right++;
            }
            if (left == right) {
                maxlength = Math.max(maxlength, 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) {
                maxlength = Math.max(maxlength, 2 * left);
            } else if (left > right) {
                left = right = 0;
            }
        }
        return maxlength;
    }
}