leetcode -- 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.

Version 1

仅仅考虑了()()这种情况，当input:()(())时输出为2，expected为:6

(())也是valid parentheses

public class Solution {
    public int longestValidParentheses(String s) {
        // Start typing your Java solution below
        // DO NOT write main() function
        int max = 0;
        int len = s.length();
        Stack<Character> stack = new Stack<Character>();
        int lastIndex = -1;
        
        int curLen = 0;
        for(int i = 0; i < len; i++){
            if(!stack.empty()){
                char top = stack.peek();
                char c = s.charAt(i);
                
                if(match(top, c)){
                    if(i - lastIndex == 2){
                       curLen += 2; 
                       lastIndex = i;
                       if(curLen > max){
                            max = curLen;
                       }
                    } else {
                        curLen = 2;
                        if(curLen > max){
                            max = curLen;
                        }
                        lastIndex = i;
                    }
                    stack.pop();
                } else {
                    stack.push(c);
                }
            } else {
                char c = s.charAt(i);
                stack.push(c);
            }
        }
        
        return max;
    }
    
    boolean match(char a, char b){
        if(a == '(' && b == ')'){
            return true;
        } else {
            return false;
        }
    }
}

Version 2：

通过维护一个左边界来计算Longest Valid Parentheses

class Node{
    char c;
    int i;
    public Node(char c, int i){
        this.c = c;
        this.i = i;
    }
}

public class Solution {
    public int longestValidParentheses(String s) {
        // Start typing your Java solution below
        // DO NOT write main() function
        int max = 0;
        int len = s.length();
        Stack<Node> stack = new Stack<Node>();
        int lastIndex = -1;
        
        int curLen = 0;
        for(int i = 0; i < len; i++){
            if(!stack.empty()){
                Node top = stack.peek();
                char c = s.charAt(i);
                
                if(match(top.c, c)){
                    stack.pop();
                    if(stack.empty()){
                        max = Math.max(max, i- (-1));
                    } else{
                        max = Math.max(max, i - (stack.peek()).i);
                    }
                    
                } else {
                    stack.push(new Node(c, i));
                }
            } else {
                char c = s.charAt(i);
                stack.push(new Node(c, i));
            }
        }
        
        return max;
    }
    
    boolean match(char a, char b){
        if(a == '(' && b == ')'){
            return true;
        } else {
            return false;
        }
    }
    
}

参考：http://fisherlei.blogspot.com/2013/03/leetcode-longest-valid-parentheses.html

http://www.cnblogs.com/remlostime/archive/2012/11/25/2787878.html

对代码进行重构，'('只会入栈，')'可能入栈，可能出栈

Version 3

class Node{
    char c;
    int i;
    public Node(char c, int i){
        this.c = c;
        this.i = i;
    }
}

public class Solution {
    public int longestValidParentheses(String s) {
        int max = 0;
        int len = s.length();
        Stack<Node> stack = new Stack<Node>();
        stack.push(new Node(')', -1));        
        int curLen = 0;
        for(int i = 0; i < len; i++){
            char c = s.charAt(i);
            if(c == '('){
                stack.push(new Node(c, i));
            } else {
                Node top = stack.peek();
                if(top.c == '('){
                    stack.pop();
                    max = Math.max(max, i - stack.peek().i);
                } else {
                    stack.push(new Node(c, i));
                }
            }
        }
        return max;
    }
}