Check if a Parentheses String Can Be Valid

Check if a Parentheses String Can Be Valid - Problem

A parentheses string is a non-empty string consisting only of '(' and ')'. It is valid if any of the following conditions is true:

It is ().
It can be written as AB (A concatenated with B), where A and B are valid parentheses strings.
It can be written as (A), where A is a valid parentheses string.

You are given a parentheses string s and a string locked, both of length n. locked is a binary string consisting only of '0's and '1's. For each index i of locked:

If locked[i] is '1', you cannot change s[i].
If locked[i] is '0', you can change s[i] to either '(' or ')'.

Return true if you can make s a valid parentheses string. Otherwise, return false.

Input & Output

Example 1 — Simple Valid Case

$ Input: s = "))", locked = "00"

› Output: true

💡 Note: Both positions are unlocked. We can change them to "()" to make a valid parentheses string.

Example 2 — Impossible Case

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

› Output: false

💡 Note: String has odd length (3), so it's impossible to create a valid parentheses string.

Example 3 — Mixed Locked/Unlocked

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

› Output: true

💡 Note: Positions 0,2 are locked as '('. Positions 1,3 are unlocked, we can set them to ')' to get "()()".

Constraints

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

Visualization

Tap to expand

Asked in

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

The key insight is that we need exactly n/2 opening and n/2 closing brackets, and we can greedily assign unlocked positions. The greedy approach works optimally by ensuring we never run out of opening brackets when we need them. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Try All Combinations

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

For each unlocked position, try both '(' and ')' characters. Generate all 2^k combinations where k is the number of unlocked positions, then check if any combination results in a valid parentheses string.

Greedy Two-Pass Strategy

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

First pass left-to-right: assign '(' to unlocked positions when we need more opening brackets. Second pass right-to-left: assign ')' to remaining unlocked positions when we need closing brackets. This ensures proper balance and nesting.

Stack-Based Simulation

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

Traverse the string and simulate parentheses matching using a stack. For locked positions, follow the character. For unlocked positions, greedily choose '(' when we need more opening brackets, or ')' when we have excess opening brackets to close.

Brute Force - Try All Combinations — Algorithm Steps

Find all unlocked positions
Generate all 2^k combinations for unlocked slots
For each combination, check if resulting string is valid
Return true if any valid combination exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Unlocked

Identify positions where locked[i] = '0'

Generate Combinations

Try all 2^k possibilities for unlocked slots

Validate

Check if any combination creates valid parentheses

Code -

solution.c — C

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

bool isValid(char* parentheses) {
    int balance = 0;
    int len = strlen(parentheses);
    for (int i = 0; i < len; i++) {
        if (parentheses[i] == '(') {
            balance++;
        } else {
            balance--;
            if (balance < 0) {
                return false;
            }
        }
    }
    return balance == 0;
}

bool tryCombinations(int index, int* unlocked, int unlocked_count, char* currentS) {
    if (index == unlocked_count) {
        return isValid(currentS);
    }
    
    int pos = unlocked[index];
    // Try '('
    currentS[pos] = '(';
    if (tryCombinations(index + 1, unlocked, unlocked_count, currentS)) {
        return true;
    }
    
    // Try ')'
    currentS[pos] = ')';
    if (tryCombinations(index + 1, unlocked, unlocked_count, currentS)) {
        return true;
    }
    
    return false;
}

bool solution(char* s, char* locked) {
    int n = strlen(s);
    int* unlocked = malloc(n * sizeof(int));
    int unlocked_count = 0;
    
    // Find all unlocked positions
    for (int i = 0; i < n; i++) {
        if (locked[i] == '0') {
            unlocked[unlocked_count++] = i;
        }
    }
    
    char* currentS = malloc((n + 1) * sizeof(char));
    strcpy(currentS, s);
    
    bool result = tryCombinations(0, unlocked, unlocked_count, currentS);
    
    free(unlocked);
    free(currentS);
    return result;
}

int main() {
    char s[100001], locked[100001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    fgets(locked, sizeof(locked), stdin);
    locked[strcspn(locked, "\n")] = 0;
    
    bool result = solution(s, locked);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^k × n)

2^k combinations where k is unlocked positions, each taking O(n) to validate

✓ Linear Growth

Space Complexity

O(k)

Recursion stack depth for generating combinations

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

847 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