Longest Valid Parentheses

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

func longestValidParentheses(s string) int {
    st := []int{-1}
    ans := 0
    for i := 0; i < len(s); i++ {
        if s[i] == '(' {
            st = append(st, i)
        } else {
            st = st[:len(st)-1]
            if len(st) == 0 {
                st = append(st, i)
            } else {
                if cur := i - st[len(st)-1]; cur > ans {
                    ans = cur
                }
            }
        }
    }
    return ans
}

class Solution:
    def longestValidParentheses(self, s: str) -> int:
        st = [-1]
        ans = 0
        for i, ch in enumerate(s):
            if ch == '(':
                st.append(i)
            else:
                st.pop()
                if not st:
                    st.append(i)
                else:
                    ans = max(ans, i - st[-1])
        return ans

function longestValidParentheses(s) {
    const st = [-1];
    let ans = 0;
    for (let i = 0; i < s.length; i++) {
        if (s[i] === '(') {
            st.push(i);
        } else {
            st.pop();
            if (st.length === 0) {
                st.push(i);
            } else {
                const cur = i - st[st.length - 1];
                if (cur > ans) ans = cur;
            }
        }
    }
    return ans;
}

class Solution {
    public int longestValidParentheses(String s) {
        Deque<Integer> st = new ArrayDeque<>();
        st.push(-1);
        int ans = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '(') {
                st.push(i);
            } else {
                st.pop();
                if (st.isEmpty()) {
                    st.push(i);
                } else {
                    ans = Math.max(ans, i - st.peek());
                }
            }
        }
        return ans;
    }
}

function longestValidParentheses(s: string): number {
    const st: number[] = [-1];
    let ans = 0;
    for (let i = 0; i < s.length; i++) {
        if (s[i] === '(') {
            st.push(i);
        } else {
            st.pop();
            if (st.length === 0) {
                st.push(i);
            } else {
                const cur = i - st[st.length - 1];
                if (cur > ans) ans = cur;
            }
        }
    }
    return ans;
}