Maximum Nesting Depth of Two Valid Parentheses Strings

Maximum Nesting Depth of Two Valid Parentheses Strings - Problem

String Stack Medium

A string is a valid parentheses string (denoted VPS) if and only if it consists of ( and ) characters only, and:

It is the empty string, or
It can be written as AB (A concatenated with B), where A and B are VPS's, or
It can be written as (A), where A is a VPS.

We can similarly define the nesting depth depth(S) of any VPS S as follows:

depth("") = 0
depth(A + B) = max(depth(A), depth(B)), where A and B are VPS's
depth("(" + A + ")") = 1 + depth(A), where A is a VPS.

For example, "", "()()", and "()(()())" are VPS's (with nesting depths 0, 1, and 2), and ")(", "(()" are not VPS's.

Given a VPS seq, split it into two disjoint subsequences A and B, such that A and B are VPS's (and A.length + B.length = seq.length).

Now choose any such A and B such that max(depth(A), depth(B)) is the minimum possible value.

Return an answer array (of length seq.length) that encodes such a choice of A and B: answer[i] = 0 if seq[i] is part of A, else answer[i] = 1.

Input & Output

Example 1 — Balanced Distribution

$ Input: seq = "(()())"

› Output: [0,1,1,1,1,0]

💡 Note: Split into A="()" (depth 1) and B="()()" (depth 1). The maximum depth is min(1,1) = 1, which is optimal.

Example 2 — Simple Case

$ Input: seq = "()(())"

› Output: [0,0,1,1,1,1]

💡 Note: Split into A="()" (depth 1) and B="()()" (depth 1). Both have depth 1, giving maximum depth of 1.

Example 3 — Nested Structure

$ Input: seq = "(((())))"

› Output: [0,1,0,1,1,0,1,0]

💡 Note: Alternating assignment distributes nested levels evenly: A="(())" (depth 2) and B="(())" (depth 2), max depth = 2.

Constraints

1 ≤ seq.length ≤ 10⁴
seq is a valid parentheses string

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 20 a Amazon 15

The key insight is that to minimize the maximum depth, we need to distribute parentheses alternately between two groups based on their nesting level. The optimal approach uses depth tracking with parity-based assignment. Time: O(n), Space: O(1).

Common Approaches

✓ Greedy

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

Brute Force - Try All Splits

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

Try every possible way to assign each parenthesis to either subsequence A or B, check if both form valid VPS, and track the minimum maximum depth.

Stack-Based Depth Tracking

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

Use the insight that to minimize maximum depth, we should distribute parentheses alternately at each nesting level. Track current depth with a stack-like counter and assign based on depth parity.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int* solution(char* seq, int n) {
    int* result = malloc(n * sizeof(int));
    int depth = 0;
    
    for (int i = 0; i < n; i++) {
        if (seq[i] == '(') {
            // Assign based on current depth parity
            result[i] = depth % 2;
            depth++;
        } else { // seq[i] == ')'
            // Decrement depth first
            depth--;
            // Then assign based on the depth of the matching '('
            result[i] = depth % 2;
        }
    }
    
    return result;
}

int main() {
    char seq[10000];
    fgets(seq, sizeof(seq), stdin);
    
    // Remove newline if present
    int len = strlen(seq);
    if (len > 0 && seq[len-1] == '\n') {
        seq[len-1] = '\0';
        len--;
    }
    
    int* result = solution(seq, len);
    
    printf("[");
    for (int i = 0; i < len; i++) {
        printf("%d", result[i]);
        if (i < len - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

42.0K Views

Medium Frequency

~15 min Avg. Time

892 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