[LeetCode] Longest Valid Parentheses

第一种方法，用栈实现，最容易想到，也比较容易实现,每次碰到‘)’时update max_len,由于要保存之前的‘(’的index，所以space complexity 是O(n)

// 使用栈，时间复杂度 O(n)，空间复杂度 O(n)
class Solution {
    public:
        int longestValidParentheses(string s) {
            int max_len = 0, last = -1; 
            stack<int> lefts; 
            for (int i = 0; i < s.size(); ++i) {
                if (s[i] =='(') {
                    lefts.push(i);
                } else {
                    if (lefts.empty()) {
                        // update last
                        last = i;
                    } else {
                        // find a matching pair
                        lefts.pop();
                        if (lefts.empty()) {
                            max_len = max(max_len, i-last);
                        } else {
                            max_len = max(max_len, i-lefts.top());21                         }
                    }
                }
            }
            return max_len;
        }
};

 

第二种方方法，搞一个计数器，每次遇到'('加一，遇到‘)’ 减少一，所以只有在计数器==0的时候更新 max_len。为了实现功能，必须两侧扫描，从而在计数器==0的时候更新max_len.

例如( ( () () 由于左括号多，因此从左侧扫描无法达到计数器==0，所以，max_len还是0.但当从右侧扫描是，右括号较少，会达到0，从而得到真实的max_len.保存start的思想和栈方法一致。

 

// LeetCode, Longest Valid Parenthese
// 两遍扫描，时间复杂度 O(n)，空间复杂度 O(1)
// @author 曹鹏 
class Solution {
    public:
        int longestValidParentheses(string s)
        {
            int answer = 0, depth = 0, start = -1;
            for (int i = 0; i < s.size(); ++i) {
                if (s[i] == '(') {
                    ++depth;
                } else {
                    --depth;
                    if (depth < 0) {
                        start = i;
                        depth = 0;
                    } else if (depth == 0) {
                        answer = max(answer, i - start);
                    }
                }
            }
            depth = 0;
            start = s.size();
            for (int i = s.size() - 1; i >= 0; --i) {
                if (s[i] == ')') {
                    ++depth;
                } else {
                    --depth;
                    if (depth < 0) {
                        start = i;
                        depth = 0;
                    } else if (depth == 0) {
                        answer = max(answer, start - i);
                    }
                }
            }
            return answer;
        }
};