LeetCode31:Longest Valid Parentheses

Given a string containing just the characters '(' and ')', find the length of the longest valid (well-formed) parentheses substring.

For "(()", the longest valid parentheses substring is "()", which has length = 2.

Another example is ")()())", where the longest valid parentheses substring is "()()", which has length = 4.

public class Solution {
    public int longestValidParentheses(String s) {
        // Start typing your Java solution below
        // DO NOT write main() function
        int longest=0;
        Stack<Character> parenStack = new Stack<Character>();
        Stack<Integer> lenStack = new Stack<Integer>();
        int curLen=0;
        for(int i=0; i<s.length(); i++){
            char ch = s.charAt(i);
            if(ch=='('){
                parenStack.push(ch);
                lenStack.push(curLen);
                curLen=0;
            }
            else{
                if(parenStack.isEmpty()){
                    longest=longest<curLen?curLen:longest;
                    curLen=0;
                }
                else{
                    parenStack.pop();
                    curLen+=2;
                    if(!lenStack.isEmpty())
                        curLen+=lenStack.pop();
                }
            }
        }
        // !!!!!!!!forgot to compare this one!!!!!!!!!!!!!!
        longest=longest<curLen?curLen:longest;
        while(!lenStack.isEmpty()){
            curLen=lenStack.pop();
            longest=longest<curLen?curLen:longest;
        }
        return longest;
    }
}

------------------------------------------------------------------------------------------------------------------------------------------

LL's solution 1: fail in this '()(()' 无法区分非连续的

public class Solution {
    public int longestValidParentheses(String s) {
        // Start typing your Java solution below
        // DO NOT write main() function
        int len = s.length();
        if(len<2)
            return 0;
        int max = 0;
        int res = 0;
        Stack st = new Stack();
        char cur;
        for(int i = 0; i<len; i++){
            cur = s.charAt(i);
            if(cur == '(')
                st.push(cur);
            else{       // cur = ')' is if can pop
                if(!st.isEmpty()){ // can pop
                    st.pop();
                    max += 2;
                }
                else{   // can't pop
                    max = 0;
                }      
            }
            if(max>res)
                res = max;
        }
        return res;
    }
}

solution 2:

新增index的stack，对于最后stack里面unclosed ‘(’ 分段比较，取最大的。

public class Solution {
    public int longestValidParentheses(String s) {
        // Start typing your Java solution below
        // DO NOT write main() function
        int len = s.length();
        if(len<2)
            return 0;
        int max = 0;
        int res = 0;
        Stack st = new Stack();
        Stack<Integer> index = new Stack<Integer>();
        char cur;
        
        for(int i = 0; i<len; i++){
            cur = s.charAt(i);
            if(cur == '('){
                st.push(cur);
                index.push(i);
            }
            else{       // cur = ')' is if can pop
                if(!st.isEmpty()){ // can pop
                    st.pop();
                    index.pop();
                    max += 2;
                } 
                else{   // can't pop
                    max = 0;
                }
            }
            if(max>res)
                res = max;   
        }
        
        if(!st.isEmpty()){        
            int tmp = 0;
            int start=0,end = len;
            while(!st.isEmpty()){ // there is '(' not closed
                start = index.pop();
                st.pop();
                if(start!=len-1){
                    res = Math.max(longestValidParentheses(s.substring(start+1,end)),tmp);
                    tmp = res;
                }
                end = start;
            }
            res = Math.max(longestValidParentheses(s.substring(0,start)),tmp);
        }
        
        return res;
    }
}