Longest Valid Parentheses - Practice Coding Problems

Longest Valid Parentheses - Problem

The Challenge: You're given a string containing only parentheses characters '(' and ')'. Your task is to find the length of the longest contiguous substring that forms valid (well-formed) parentheses.

What makes parentheses valid?
• Every opening parenthesis '(' must have a corresponding closing parenthesis ')'
• They must be in the correct order (no closing before its matching opening)

Example: In the string

"(()", the longest valid parentheses substring is "()" with length 2.

Goal: Return the length of the longest valid parentheses substring, not the substring itself.



                        
                        
                            
                                    Input & Output
                                    
                                    
                                                                                     

                                
                            
                                
                                                                                                        
                                        
                                            
                                            
                                            
                                            example_1.py — Basic Valid Parentheses
                                        
                                        
                                                                                            
                                                
                                                    $
                                                    Input:
                                                    s = "(()"
# String with one valid pair
                                                
                                                
                                                    ›
                                                    Output:
                                                    2
                                                
                                                                                        
                                                                                        
                                                
                                                    💡 Note:
                                                    The longest valid parentheses substring is "()" which has length 2. The first '(' cannot be matched.
                                                
                                            
                                                                                    
                                    
                                                                        
                                        
                                            
                                            
                                            
                                            example_2.py — Multiple Valid Pairs
                                        
                                        
                                                                                            
                                                
                                                    $
                                                    Input:
                                                    s = ")()())"
# String with consecutive valid pairs
                                                
                                                
                                                    ›
                                                    Output:
                                                    4
                                                
                                                                                        
                                                                                        
                                                
                                                    💡 Note:
                                                    The longest valid parentheses substring is "()()" which has length 4. The first and last characters cannot form valid pairs.
                                                
                                            
                                                                                    
                                    
                                                                        
                                        
                                            
                                            
                                            
                                            example_3.py — Empty String Edge Case
                                        
                                        
                                                                                            
                                                
                                                    $
                                                    Input:
                                                    s = ""
# Empty string
                                                
                                                
                                                    ›
                                                    Output:
                                                    0
                                                
                                                                                        
                                                                                        
                                                
                                                    💡 Note:
                                                    Empty string contains no parentheses, so the longest valid parentheses substring has length 0.
                                                
                                            
                                                                                    
                                    
                                                                                                
                        

                        
                        
                            
                                
                                     
                                    Constraints
                                
                                
                                    
                                
                            
                            
                                
                                                                                                                        
                                                0 ≤ s.length ≤ 3 × 10⁴                                            
                                                                                    
                                                s[i] is either '(' or ')'                                            
                                                                                    
                                                String contains only parentheses characters                                            
                                                                                                            
                            
                        

                        
                                                
                            
                                
                                    
                                    Visualization
                                
                                
                                    
                                
                            
                            
                                
                                     Tap to expand
                                                                    
                                
                                                                
                                    
                                        
                                        Understanding the Visualization
                                    
                                    
                                                                                    
                                                1
                                                
                                                    Identify the Pattern
                                                    Valid parentheses form nested or sequential patterns where every '(' has a matching ')' after it
                                                
                                            
                                                                                    
                                                2
                                                
                                                    Track with Stack
                                                    Use a stack to remember positions of unmatched '(' characters and calculate lengths when we find matches
                                                
                                            
                                                                                    
                                                3
                                                
                                                    Calculate Lengths
                                                    When we find a ')', match it with the most recent '(' and calculate the length of the valid sequence
                                                
                                            
                                                                                    
                                                4
                                                
                                                    Handle Edge Cases
                                                    Manage cases where ')' appears without matching '(' by updating our base position for calculations
                                                
                                            
                                                                            
                                    
                                                                        
                                        
                                            
                                        
                                        
                                            Key Takeaway
                                            
                                            🎯 Key Insight: The stack-based approach efficiently tracks unmatched parentheses positions, allowing us to calculate the length of valid sequences in O(n) time by leveraging the stack's top element as a reference point for distance calculations.                                            
                                        
                                    
                                                                    
                                                            
                        
                        
                        
                        
                            
                                
                                    
                                    Related Problems
                                
                                
                                    
                                
                            
                            
                                                                                                                                                
                                            #1
                                            Valid Parentheses
                                            Easy
                                        
                                                                                                
                        

                        
                        
                            
                                
                                Asked in
                            
                            
                                                                                                            
                                            G
                                            Google                                            42
                                        
                                                                            
                                            a
                                            Amazon                                            38
                                        
                                                                            
                                            f
                                            Meta                                            29
                                        
                                                                            
                                            ⊞
                                            Microsoft                                            25
                                        
                                                                            
                                            
                                            Apple                                            18



            

    




    
        
            Longest Valid Parentheses — Solution
            
        
    



    
        The optimal solution uses a stack-based approach to track indices of unmatched parentheses. By maintaining a stack and calculating lengths when matches are found, we achieve O(n) time complexity. Alternative approaches include dynamic programming which builds the solution incrementally, and brute force which checks all possible substrings but is inefficient for large inputs.    





    
        
            
            Common Approaches
        
        
            
        
    
    
        
        
            
                
                    Approach
                    Time
                    Space
                    Notes
                
            
            
            
                                
                    
                                                    ✓ 
                                                Brute Force (Check All Substrings)                    
                    
                        O(n³)                    
                    
                        O(1)                    
                    
                        Check every possible substring to see if it's valid parentheses                    
                
                                
                    
                                                Stack-Based Solution (Optimal)                    
                    
                        O(n)                    
                    
                        O(n)                    
                    
                        Use stack to track indices and find longest valid parentheses efficiently                    
                
                                
                    
                                                Dynamic Programming                    
                    
                        O(n)                    
                    
                        O(n)                    
                    
                        Build solution incrementally using previously computed results                    
                
                            
        
        
    




    
    
        
            
                
                Brute Force (Check All Substrings) — Algorithm Steps
            
            
                
            
        
        
            
                                Generate all possible substrings of the input string
                                For each substring, check if it forms valid parentheses using a counter
                                Track the maximum length among all valid substrings
                                Return the maximum length found
                            
        
    

    

    
        
            
            Visualization
        
        
            
        
    
    
        
             Tap to expand
            
                            
        
        
                
            
                
                Step-by-Step Walkthrough
            
            
                                
                    
                        1                    
                    
                        
                            Generate Substrings                        
                        
                            Start with all possible starting positions                        
                    
                
                                
                    
                        2                    
                    
                        
                            Check Validity                        
                        
                            For each substring, validate parentheses using counter                        
                    
                
                                
                    
                        3                    
                    
                        
                            Track Maximum                        
                        
                            Keep track of the longest valid substring found                        
                    
                
                            
        
            


    
    
        
            
                
                    
                    Code -
                
                                
                    
                    
                    
                    
                    
                    
                
                            
            
                
            
        
        
        
        
            
            
                
                
                    
                    
                    
                
                
                solution.c — C
            
            
            
                
                #include <stdio.h>
#include <string.h>
#include <stdbool.h>

bool isValid(char* s, int start, int length) {
    int count = 0;
    for (int i = start; i < start + length; i++) {
        if (s[i] == '(') {
            count++;
        } else if (s[i] == ')') {
            count--;
            if (count < 0) return false;
        }
    }
    return count == 0;
}

int longestValidParentheses(char* s) {
    int n = strlen(s);
    int maxLength = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 2; j <= n; j += 2) {
            if (isValid(s, i, j - i)) {
                if (j - i > maxLength) {
                    maxLength = j - i;
                }
            }
        }
    }
    
    return maxLength;
}

int main() {
    char s[100001];
    fgets(s, sizeof(s), stdin);
    
    // Remove quotes and newline
    int len = strlen(s);
    if (s[len-1] == '\n') s[len-1] = '\0';
    char* start = s;
    if (*start == '"') start++;
    len = strlen(start);
    if (start[len-1] == '"') start[len-1] = '\0';
    
    printf("%d\n", longestValidParentheses(start));
    return 0;
}
            
        
        
    



    
        
            
            Time & Space Complexity
        
        
            
        
    
    
        
            
            
                
                    Time Complexity
                    
                        ⏱️
                        O(n³)
                    
                
                
                    O(n²) for generating all substrings × O(n) for validating each substring
                    
                        
                            n
                            
                                
                            
                        
                        
                            2n
                            
                                
                            
                        
                    
                    
                        ⚠ Quadratic Growth                    
                
            

            
            
                
                    Space Complexity
                    
                        
                            
                        
                        O(1)
                    
                
                
                    Only using a few variables for counting and tracking maximum length
                    
                        
                            n
                            
                                
                            
                        
                        
                            2n
                            
                                
                            
                        
                    
                    
                        ✓ Linear Space                    
                
            
        
    
  





            
            
                
                    
                        
                    
                    
                        142.4K                    
                    Views
                
                
                    
                        
                    
                    High
                    Frequency
                
                
                    
                        
                    
                    ~25 min
                    Avg. Time
                
                
                    
                        
                    
                    
                        2.8K                    
                Likes

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n³)	O(1)	Check every possible substring to see if it's valid parentheses
Stack-Based Solution (Optimal)	O(n)	O(n)	Use stack to track indices and find longest valid parentheses efficiently
Dynamic Programming	O(n)	O(n)	Build solution incrementally using previously computed results



        

        
            
                
                
                    
                        
                        
                        
                        
                        
                        
                    
                    
                        
                        
                        
                    
                
                
                
                
    
    
        Ln 1, Col 1
    
    
    
    
        Smart Actions
        
        
        
        
        
    
    
    
    
        
            
                💡
                Explanation
            
            
        
        
            
        
        
            
            
        
    
    
        
        AI Ready
    
    
        💡 Suggestion
        Tab
        to accept
        Esc
        to dismiss
    

                
                

    
    
        
            
                
                
                
                
            
        
        
            
                
            
            
                
            
            
                
            
        
    
    
        
            // Output will appear here after running code
        
    
    
        
    

            
            
            
                
                    
                
                Code Editor Closed
                Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler