Check if a Parentheses String Can Be Valid

Check if a Parentheses String Can Be Valid - Problem

🔓 Unlock the Valid Parentheses

Imagine you have a string of parentheses where some positions are locked and cannot be changed, while others are flexible and can be modified to either '(' or ')'.

Your challenge is to determine if you can manipulate the flexible positions to create a perfectly balanced parentheses string. A valid parentheses string follows these rules:

It equals "()", or
It can be formed by concatenating two valid strings: AB, or
It can be formed by wrapping a valid string: (A)

Input: Two strings of equal length n:

s - the parentheses string containing only '(' and ')'
locked - a binary string where '1' means position is locked, '0' means flexible

Output: Return true if you can make s valid by changing flexible positions, false otherwise.

Example: s = ")())", locked = "0100" → We can change the first ')' to '(' to get "(())", which is valid!

Input & Output

example_1.py — Basic Valid Case

$ Input: s = ")())", locked = "0100"

› Output: true

💡 Note: We can change s[0] from ')' to '(' since locked[0] = '0'. This gives us "(())" which is valid: it can be written as (()) where the inner content is ().

example_2.py — All Flexible

$ Input: s = "((((", locked = "0000"

› Output: true

💡 Note: All positions are flexible. We can change this to "(())" or "()()" or any other valid combination. For example: change positions 2,3 to ')' to get "(())".

example_3.py — Impossible Case

$ Input: s = "())", locked = "000"

› Output: false

💡 Note: The string has odd length (3), so it's impossible to create a valid parentheses string since valid strings must have even length (equal numbers of '(' and ')').

Visualization

Tap to expand

Understanding the Visualization

Identify Gate Types

Some gates are broken (locked) and can't change, others are flexible and can be set to entry or exit

Left Flow Check

Ensure at no point do we have more cars exiting than have entered (negative count)

Right Flow Check

Working backwards, ensure we can balance all cars by setting flexible gates optimally

Final Validation

If both flow checks pass, we can create a valid configuration

Key Takeaway

🎯 Key Insight: We don't need to assign exact values to flexible positions - we just need to prove that a valid assignment exists by ensuring flow constraints are never violated.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two linear passes through the string

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track counts

✓ Linear Space

Constraints

n == s.length == locked.length
1 ≤ n ≤ 10⁵
s[i] is either '(' or ')'
locked[i] is either '0' or '1'

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses a two-pass greedy approach in O(n) time. Key insight: we don't need to know exact flexible position assignments - just verify it's possible to maintain valid parentheses count. Left-to-right pass ensures we never have more closes than opens so far, right-to-left pass ensures we can balance everything by the end.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Greedy (Optimal)	O(n)	O(1)	Use greedy approach with two passes to track balance range
Brute Force (Try All Combinations)	O(2^k * n)	O(n)	Generate all possible assignments for flexible positions and check validity

Two-Pass Greedy (Optimal) — Algorithm Steps

Check if string length is odd (impossible case)
Left-to-right pass: track minimum possible open parentheses count
Ensure count never goes negative (more closes than opens so far)
Right-to-left pass: track minimum possible close parentheses count
Ensure we can balance everything by the end
Return true if both passes succeed

Visualization

Tap to expand

Step-by-Step Walkthrough

Left Pass

Ensure we never have more closes than opens so far

Count Tracking

Treat flexible positions optimally for current direction

Right Pass

Ensure we can balance everything by treating flexible positions as closes

Final Decision

Valid if both passes succeed

Code -

solution.c — C

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

bool canBeValid(char* s, char* locked) {
    int n = strlen(s);
    if (n % 2 == 1) return false;
    
    // Left to right pass
    int openCount = 0;
    for (int i = 0; i < n; i++) {
        if (locked[i] == '0' || s[i] == '(') {
            openCount++;
        } else {
            openCount--;
        }
        
        if (openCount < 0) {
            return false;
        }
    }
    
    // Right to left pass
    int closeCount = 0;
    for (int i = n - 1; i >= 0; i--) {
        if (locked[i] == '0' || s[i] == ')') {
            closeCount++;
        } else {
            closeCount--;
        }
        
        if (closeCount < 0) {
            return false;
        }
    }
    
    return true;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two linear passes through the string

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track counts

✓ Linear Space

Constraints

n == s.length == locked.length
1 ≤ n ≤ 10⁵
s[i] is either '(' or ')'
locked[i] is either '0' or '1'

42.5K Views

High Frequency

~22 min Avg. Time

1.3K 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

🔓 Unlock the Valid Parentheses

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two-Pass Greedy (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler