Valid Parenthesis String

Valid Parenthesis String - Problem

Given a string s containing only three types of characters: '(', ')' and '*', return true if s is valid.

The following rules define a valid string:

Any left parenthesis '(' must have a corresponding right parenthesis ')'.
Any right parenthesis ')' must have a corresponding left parenthesis '('.
Left parenthesis '(' must go before the corresponding right parenthesis ')'.
'*' could be treated as a single right parenthesis ')' or a single left parenthesis '(' or an empty string "".

Input & Output

Example 1 — Basic Wildcard

$ Input: s = "()"

› Output: true

💡 Note: Simple balanced parentheses without any wildcards

Example 2 — Wildcard as Close

$ Input: s = "(*)"

› Output: true

💡 Note: The '*' can be treated as ')' to balance the '('

Example 3 — Complex Case

$ Input: s = "(*))"

› Output: true

💡 Note: The '*' can be '(' making it '(()))', then balanced by treating another as empty

Constraints

1 ≤ s.length ≤ 100
s[i] is '(', ')' or '*'

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 M Microsoft 15 f Facebook 18

The key insight is treating wildcards as flexible characters. The optimal greedy approach tracks the range of possible open parentheses counts, ensuring 0 is achievable. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Try All Combinations

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

For each '*', try all three possibilities: '(', ')', or empty. Use recursion to explore all combinations and check if any results in a valid parenthesis string.

Greedy - Balance Range Tracking

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

Maintain minimum and maximum possible counts of unmatched open parentheses. For each '*', adjust the range considering all possibilities. String is valid if 0 is within the final range.

Two-Stack Approach

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

Maintain separate stacks for '(' positions and '*' positions. When encountering ')', try to match with '(' first, then '*'. Finally, match remaining '(' with '*' that come after them.

Brute Force - Try All Combinations — Algorithm Steps

For each '*', recursively try '(', ')', and empty
Check if resulting string has balanced parentheses
Return true if any combination is valid

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Stars

Identify all '*' positions in string

Try Combinations

For each '*', try '(', ')', or empty

Validate

Check if any combination is balanced

Code -

solution.c — C

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

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

bool backtrack(const char* s, int i, char* current, int curr_len) {
    int len = strlen(s);
    if (i == len) {
        current[curr_len] = '\0';
        return isValid(current);
    }
    
    if (s[i] == '*') {
        current[curr_len] = '(';
        if (backtrack(s, i + 1, current, curr_len + 1)) return true;
        
        current[curr_len] = ')';
        if (backtrack(s, i + 1, current, curr_len + 1)) return true;
        
        if (backtrack(s, i + 1, current, curr_len)) return true;
        
        return false;
    } else {
        current[curr_len] = s[i];
        return backtrack(s, i + 1, current, curr_len + 1);
    }
}

bool solution(const char* s) {
    char current[1001];
    return backtrack(s, 0, current, 0);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(3ⁿ)

For each of n '*' characters, we try 3 possibilities

✓ Linear Growth

Space Complexity

O(n)

Recursion depth can go up to n levels

⚡ Linearithmic Space

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler