Maximum Nesting Depth of Two Valid Parentheses Strings

Maximum Nesting Depth of Two Valid Parentheses Strings - Problem

String Stack Medium

Maximum Nesting Depth of Two Valid Parentheses Strings

Imagine you have a valid parentheses string (VPS) - a string containing only '(' and ')' characters that forms a perfectly balanced expression. Your task is to split this string into two subsequences such that both subsequences are also valid parentheses strings.

The nesting depth of a VPS is the maximum number of nested parentheses at any point. For example:

"()()" has depth 1
"(())" has depth 2
"((()))" has depth 3

Your goal is to split the original string into two subsequences A and B such that the maximum depth between A and B is minimized. In other words, you want to balance the nesting depth as evenly as possible between the two strings.

Return an array where answer[i] = 0 if character i belongs to subsequence A, and answer[i] = 1 if it belongs to subsequence B.

Input & Output

example_1.py — Basic Case

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

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

💡 Note: Split into A="(())" (depth=2) and B="()" (depth=1). Max depth = max(2,1) = 2. Alternative splits might give higher max depths.

example_2.py — Deep Nesting

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

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

💡 Note: Alternating assignment creates A="(())" and B="(())", each with depth=2. This is optimal since any other split would create uneven depths.

example_3.py — Simple Case

$ Input: seq = "()()"

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

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

Constraints

2 ≤ seq.length ≤ 10⁵
seq consists only of '(' and ')' characters
seq is a valid parentheses string

Visualization

Tap to expand

Understanding the Visualization

Track Current Level

Monitor the current nesting depth as we process each parenthesis

Alternate by Depth

Assign parentheses to Team 0 when depth is even, Team 1 when odd

Update Depth

Increment depth for '(' (starting new level), decrement for ')' (completing level)

Balanced Workload

Both teams end up with similar maximum nesting depths

Key Takeaway

🎯 Key Insight: By alternating team assignments based on nesting depth parity (even→Team A, odd→Team B), we automatically achieve optimal load balancing with minimal computational overhead.

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal solution uses a simple depth-tracking approach that assigns parentheses to teams based on the parity of the current nesting depth. This ensures the maximum depth difference between teams is at most 1, achieving the theoretical minimum in O(n) time with O(1) extra space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n * n)	O(n)	Generate all possible ways to split the string into two subsequences
Optimal Depth-Based Assignment	O(n)	O(1)	Assign parentheses to teams based on current nesting depth parity

Brute Force (Try All Combinations) — Algorithm Steps

Generate all 2^n possible assignments of characters to subsequences A and B
For each assignment, extract subsequences A and B
Check if both A and B are valid parentheses strings
Calculate the depth of each valid subsequence
Track the assignment with minimum max(depth(A), depth(B))

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Assignment

Create a binary assignment (0 or 1) for each character

Split Subsequences

Separate characters into two subsequences based on assignment

Validate & Calculate

Check if both subsequences are valid and calculate their depths

Track Best

Keep the assignment with minimum maximum depth

Code -

solution.c — C

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

typedef struct {
    int valid;
    int depth;
} ValidDepth;

ValidDepth isValidAndDepth(char* subseq, int len) {
    ValidDepth result = {0, 0};
    if (len == 0) {
        result.valid = 1;
        return result;
    }
    
    int depth = 0, maxDepth = 0;
    for (int i = 0; i < len; i++) {
        if (subseq[i] == '(') {
            depth++;
            if (depth > maxDepth) maxDepth = depth;
        } else {
            depth--;
            if (depth < 0) return result;
        }
    }
    
    result.valid = (depth == 0);
    result.depth = maxDepth;
    return result;
}

int* maxDepthAfterSplit(char* seq, int* returnSize) {
    int n = strlen(seq);
    *returnSize = n;
    int* bestAssignment = (int*)malloc(n * sizeof(int));
    int minMaxDepth = INT_MAX;
    
    char* subseqA = (char*)malloc((n + 1) * sizeof(char));
    char* subseqB = (char*)malloc((n + 1) * sizeof(char));
    
    // Try all 2^n possible assignments
    for (int mask = 0; mask < (1 << n); mask++) {
        int* assignment = (int*)malloc(n * sizeof(int));
        int lenA = 0, lenB = 0;
        
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                assignment[i] = 1;
                subseqB[lenB++] = seq[i];
            } else {
                assignment[i] = 0;
                subseqA[lenA++] = seq[i];
            }
        }
        
        subseqA[lenA] = '\0';
        subseqB[lenB] = '\0';
        
        ValidDepth resultA = isValidAndDepth(subseqA, lenA);
        ValidDepth resultB = isValidAndDepth(subseqB, lenB);
        
        if (resultA.valid && resultB.valid) {
            int maxDepth = (resultA.depth > resultB.depth) ? resultA.depth : resultB.depth;
            if (maxDepth < minMaxDepth) {
                minMaxDepth = maxDepth;
                memcpy(bestAssignment, assignment, n * sizeof(int));
            }
        }
        
        free(assignment);
    }
    
    free(subseqA);
    free(subseqB);
    return bestAssignment;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n)

2^n possible assignments, each requiring O(n) time to validate and calculate depth

⚠ Quadratic Growth

Space Complexity

O(n)

Space to store the current assignment and subsequences

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~12 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler