Longest Valid Parentheses

Longest Valid Parentheses - Problem

Given a string containing just the characters '(' and ')', return the length of the longest valid (well-formed) parentheses substring.

A valid parentheses substring means every opening parenthesis has a corresponding closing parenthesis in the correct order, with no unmatched parentheses.

Examples:

"(()": longest valid substring is "()" with length 2
")()())": longest valid substring is "()()" with length 4
"": empty string returns 0

Input & Output

Example 1 — Mixed Valid and Invalid

$ Input: s = ")()())"

› Output: 4

💡 Note: The longest valid parentheses substring is "()()", which has length 4. It appears in the middle of the string.

Example 2 — Simple Valid Pair

$ Input: s = "(()"

› Output: 2

💡 Note: The longest valid parentheses substring is "()", which has length 2.

Example 3 — Empty String

$ Input: s = ""

› Output: 0

💡 Note: An empty string contains no valid parentheses, so the length is 0.

Constraints

0 ≤ s.length ≤ 3 × 10⁴
s[i] is '(' or ')'.

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Facebook 32 M Microsoft 28

The key insight is to track the length of valid parentheses sequences efficiently. Best approach is Dynamic Programming with O(n) time and space, building up valid lengths incrementally. Alternative approaches include stack-based tracking and two-pointer counting for O(1) space.

Common Approaches

✓ Sliding Window

⏱️ Time: N/A Space: N/A

Brute Force - Check All Substrings

⏱️ Time: O(n³) Space: O(1)

For each starting position, check all substrings beginning from that position. Use a counter to verify if parentheses are balanced and well-formed.

Dynamic Programming

⏱️ Time: O(n) Space: O(n)

Use dynamic programming where dp[i] represents the length of longest valid parentheses substring ending at position i. Build the solution incrementally.

Stack-Based Approach

⏱️ Time: O(n) Space: O(n)

Maintain a stack to track indices of unmatched parentheses. When we find a valid pair, we can determine the length of valid substring ending at current position.

Two-Pointer Counting

⏱️ Time: O(n) Space: O(1)

Make two passes through the string: left-to-right counting '(' and ')', then right-to-left. This handles all edge cases without extra space.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int solution(int* nums, int numsSize, int k) {
    int left = 0;
    int zeroCount = 0;
    int maxLength = 0;
    
    for (int right = 0; right < numsSize; right++) {
        // Expand window
        if (nums[right] == 0) {
            zeroCount++;
        }
        
        // Shrink window if too many zeros
        while (zeroCount > k) {
            if (nums[left] == 0) {
                zeroCount--;
            }
            left++;
        }
        
        // Update max length
        int length = right - left + 1;
        if (length > maxLength) maxLength = length;
    }
    
    return maxLength;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[10000];
    int numsSize = 0;
    char* token = strtok(line + 1, ",");
    while (token != NULL) {
        // Remove closing bracket if present
        char* bracket = strchr(token, ']');
        if (bracket) *bracket = '\0';
        
        // Skip empty tokens
        if (strlen(token) > 0) {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, ",");
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", solution(nums, numsSize, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

277.9K Views

High Frequency

~25 min Avg. Time

8.4K Likes

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