LeetCode - Longest Valid Parentheses

Longest Valid Parentheses

2014.2.13 02:32

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.

Solution:

　　First of all, if you use a stack to simulate the push() and pop() operations with '(' and ')', you'll always get an empty stack at the end if the sequence is valid.

　　My first reaction on this problem is an O(n^2) solution by dynamic programming. Apparently it's for subsequence, not substring, as substring is consecutive. Later I thought about O(n) dynamic programming, but no good idea came to me.

　　When I tried to use a stack to simulate the sequence, I realized that the thing I pushed into the stack don't have to be the same '(', but their index.

　　With the index of '(' recorded in the stack, whenever a matching with ')' happened, I can calculate the length of that matching sequence.

　　The algorithm is online and one-pass, with the help of a stack and O(1) amount of extra parameters.

　　Total time complexity is O(n). Space complexity is O(n) as well.

Accepted code:

// 1WA, 1AC, the simpliest solution is also the best one here.
#include <algorithm>
#include <stack>
using namespace std;

class Solution {
public:
    int longestValidParentheses(string s) {
        stack<int> st;
        int i, len;
        int last_pos;
        int max_res;
        
        last_pos = -1;
        max_res = 0;
        len = (int)s.length();
        for (i = 0; i < len; ++i) {
            if (s[i] == '(') {
                st.push(i);
            } else if (s[i] == ')') {
                if (st.empty()) {
                    last_pos = i;
                } else {
                    st.pop();
                    if (st.empty()) {
                        max_res = max(max_res, i - last_pos);
                    } else {
                        max_res = max(max_res, i - st.top());
                    }
                }
            }
        }
        while (!st.empty()) {
            st.pop();
        }
        
        return max_res;
    }
};