Description

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].
• But 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.

Example 1:

Input: s = "))()))", locked = "010100"
Output: true
Explanation: locked[1] == '1' and locked[3] == '1', so we cannot change s[1] or s[3].
We change s[0] and s[4] to '(' while leaving s[2] and s[5] unchanged to make s valid.

Example 2:

Input: s = "()()", locked = "0000"
Output: true
Explanation: We do not need to make any changes because s is already valid.

Example 3:

Input: s = ")", locked = "0"
Output: false
Explanation: locked permits us to change s[0]. 
Changing s[0] to either '(' or ')' will not make s valid.

Constraints:

n == s.length == locked.length
1 <= n <= 10^5
s[i] is either '(' or ')'.
locked[i] is either '0' or '1'.

Solution

Greedy, similar to 678. Valid Parenthesis String. When iterating from left to right, if there’s ), we would prefer to use ( first, if we don’t have enough (, start using unlocked indexes. After iteration, the remaining ( should be paired with locked indexes. And in the end, the remaining unlocked indexes should be even length so they can pair themselves.

Use 2 stacks to store the ( and the unlocked indexes.

Time complexity: $o(n)$
Space complexity: $o(n)$

Code

class Solution:
    def canBeValid(self, s: str, locked: str) -> bool:
        open_p, unlocked_p = [], []
        for i in range(len(s)):
            if locked[i] == '0':
                unlocked_p.append(i)
            else:
                if s[i] == '(':
                    open_p.append(i)
                else:
                    if open_p:
                        open_p.pop()
                    elif unlocked_p:
                        unlocked_p.pop()
                    else:
                        return False
        while open_p:
            cur_open_i = open_p.pop()
            if unlocked_p and unlocked_p[-1] > cur_open_i:
                unlocked_p.pop()
            else:
                return False
        return len(unlocked_p) & 1 == 0