[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 = , last = -;
             stack<int> lefts;
             for (int i = ; 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());                         }
                     }
                 }
             }
             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 = , depth = , start = -;
             for (int i = ; i < s.size(); ++i) {
                 if (s[i] == '(') {
                     ++depth;
                 } else {
                     --depth;
                     if (depth < ) {
                         start = i;
                         depth = ;
                     } else if (depth == ) {
                         answer = max(answer, i - start);
                     }
                 }
             }
             depth = ;
             start = s.size();
             for (int i = s.size() - ; i >= ; --i) {
                 if (s[i] == ')') {
                     ++depth;
                 } else {
                     --depth;
                     if (depth < ) {
                         start = i;
                         depth = ;
                     } else if (depth == ) {
                         answer = max(answer, start - i);
                     }
                 }
             }
             return answer;
         }
 };