leetCode 32. Longest Valid Parentheses

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

Example 1:

Input: "(()"
Output: 2
Explanation: The longest valid parentheses substring is "()"

Example 2:

Input: ")()())"
Output: 4
Explanation: The longest valid parentheses substring is "()()"

超过17.81%，不是用的栈。

基本思路是：

　　从左至右遍历字符串，找出所有这样的子串[begin,end]，其任意的子串的左括号数量>有括号数量。将这样的区间放入一个区间链表left中。

　　然后从右至左遍历字符串，找出所有这样的字符串[begin,end]，其任意的子串的右括号数量>左括号的数量。　将这样的区间放入一个区间链表right中。

　　取两个区间集合left，right的交集。最大的子区间的元素数量就是最终结果。

 

　　当然区间取交集时，用二分查找还能更快，懒得写了。时间复杂度应该为O(n^2)。

class Solution {
    class Perfect {
        int start;
        int end;

        public Perfect(int start, int end) {
            this.start = start;
            this.end = end;
        }

        @Override
        public String toString() {
            return "[" + start +
                    "," + end +
                    ']';
        }
    }

    public int longestValidParentheses(String s) {
        int LL = 0, LR = 0, RL = 0, RR = 0;
        List<Perfect> left = new ArrayList<>();
        List<Perfect> right = new ArrayList<>();
        int RLborder=s.length()-1,LRborder=0;
        for (int i = 0; i < s.length(); i++) {
            //L-->R
            if (s.charAt(i) == '(')
                ++LL;
            else
                ++LR;
            if (LR > LL) {
                int start = i - (LL + LR) + 1;//有问题
                int end = i - 1;
                if (start >= 0 && end >= 0 && start < end)
                    left.add(new Perfect(start, end));
                LR = LL = 0;
                LRborder=i+1;
            }
            if (i == s.length() - 1 && LR == LL && LR != 0) {
                left.add(new Perfect(s.length() - LR - LL, s.length() - 1));
            }


            //R-->L
            if (s.charAt(s.length() - 1 - i) == '(')
                ++RL;
            else
                ++RR;
            if (RL > RR) {
                int start = s.length() - i;
                int end = s.length() - 1 - i + RL + RR - 1;
                if (start >= 0 && end <= s.length() - 1 && start < end)
                    right.add(new Perfect(start, end));
                RL = RR = 0;
                RLborder=s.length()-1-i-1;
            }
            if (s.length() - 1 - i == 0 && RL == RR && RL != 0) {
                right.add(new Perfect(0, RL + RR - 1));
            }
        }
        if (LR < LL && s.length()-LRborder !=1) {
            left.add(new Perfect(LRborder,s.length()-1));
        }
        if (RL < RR && RLborder-0!=1) {
            right.add(new Perfect(0, RLborder));
        }


        for (int j = 0; j < left.size(); j++) {
            System.out.println(left.get(j));
        }
        System.out.println("*********");
        for (int j = right.size() - 1; j >= 0; --j) {
            System.out.println(right.get(j));
        }

        //取left和right的交集
        int res = 0;
        for (int i = 0; i < left.size(); i++) {
            //left的i位置区间和right的j区间做交集
            for (int j = right.size()-1; j >=0; j--) {
                int maxStart = Math.max(left.get(i).start, right.get(j).start);
                int minEnd = Math.min(left.get(i).end, right.get(j).end);
                if (maxStart < minEnd) {
                    res = res < minEnd - maxStart +1  ? minEnd - maxStart+1 : res;
                }else if (left.get(i).start > right.get(j).end){
                    continue;
                }else
                    break;
            }
        }
        return res;
    }
}

 来一个猛的，动态规划解法，超过84.29%。

基本思路是：

　　d[i]：表示以i结尾的最长匹配的字符串长度。

　　最完美匹配字符串定义：(代码中用len表示)

　　　　像这样的：(), (()),(((())))。

　　我们只需要看i位置的最完美匹配字符串能否和前面的最长匹配字符串能不能连在一起构成一个较大的最长匹配字符串即可。

class Solution {
    public int longestValidParentheses(String s) {
        int[] d = new int[s.length()];
        int max = 0;

        for (int i = 1; i < s.length(); i++) {
            //查找以i位置结尾的最完美匹配
            int len = 0;
            if (i-1-d[i-1]>=0 && s.charAt(i) == ')' && '(' == s.charAt(i - 1 - d[i - 1])){// (())
                len=d[i-1]+2;
            }else if (!(s.charAt(i)==')' && s.charAt(i-1)=='(')){// ())
                len=0;
            }else {// (() || ()
                len = 2;
            }


            if (i-len>=0 && len!=0){
                d[i]=d[i-len]+len;
            }else {
                d[i]=len;
            }

            max = (max < d[i]) ? d[i] : max;
        }
        return max;
    }
}