LeetCode 1249. Minimum Remove to Make Valid Parentheses

原题链接在这里：https://leetcode.com/problems/minimum-remove-to-make-valid-parentheses/

题目：

Given a string s of '(' , ')' and lowercase English characters. 

Your task is to remove the minimum number of parentheses ( '(' or ')', in any positions ) so that the resulting parentheses string is valid and return any valid string.

Formally, a parentheses string is valid if and only if:

• It is the empty string, contains only lowercase characters, or
• It can be written as AB (A concatenated with B), where A and B are valid strings, or
• It can be written as (A), where A is a valid string.

Example 1:

Input: s = "lee(t(c)o)de)"
Output: "lee(t(c)o)de"
Explanation: "lee(t(co)de)" , "lee(t(c)ode)" would also be accepted.

Example 2:

Input: s = "a)b(c)d"
Output: "ab(c)d"

Example 3:

Input: s = "))(("
Output: ""
Explanation: An empty string is also valid.

Example 4:

Input: s = "(a(b(c)d)"
Output: "a(b(c)d)"

Constraints:

• 1 <= s.length <= 10^5
• s[i] is one of  '(' , ')' and lowercase English letters.

题解：

From left to right, accoulate left open parenthese. 

When encountering ")" and there is no more left "(", then this should be ignored.

Do the same thing from right left.

Time Complexity: O(n). n = s.length().

Space: O(n).

AC Java:

class Solution {
    public String minRemoveToMakeValid(String s) {
        if(s == null || s.length() == 0){
            return s;
        }
        
        StringBuilder sb = new StringBuilder();
        int left = 0;
        for(char c : s.toCharArray()){
            if(c == '('){
                left++;
            }else if(c == ')'){
                if(left == 0){
                    continue;
                }
                
                left--;
            }
            
            sb.append(c);
        }
        
        StringBuilder res = new StringBuilder();
        for(int i = sb.length()-1; i>=0; i--){
            char c = sb.charAt(i);
            if(c == '(' && left-- > 0){
                continue;
            }
            
            res.append(c);
        }
        
        return res.reverse().toString();
    }
}

If we use C++, we can directly manipulate on the s and make the space complexity as O(1) regardless res.
Time Complexity: O(n). Space: O(1).
AC C++:

class Solution {
public:
    string minRemoveToMakeValid(string s) {
        int n = s.length();
        int left = 0;
        for(int i = 0; i < n; i++){
            if(s[i] == '('){
                left++;
            }else if(s[i] == ')'){
                if(left == 0){
                    s[i] = '#';
                }else{
                    left--;
                }
            }
        }

        int right = 0;
        for(int i = n - 1; i >= 0; i--){
            if(s[i] ==')'){
                right++;
            }else if(s[i] == '('){
                if(right == 0){
                    s[i] = '#';
                }else{
                    right--;
                }
            }
        }

        string res = "";
        for(char c : s){
            if(c == '#'){
                continue;
            }

            res += c;
        }

        return res;
    }
};

AC Python:

class Solution:
    def minRemoveToMakeValid(self, s: str) -> str:
        n = len(s)
        s_list = list(s)
        left = 0
        for i in range(n):
            if s_list[i] =='(':
                left += 1
            elif s_list[i] ==')':
                if left == 0:
                    s_list[i] = ''
                else:
                    left -= 1
        
        right = 0
        for i in range(n - 1, -1, -1):
            if s_list[i] == ')':
                right += 1
            elif s_list[i] == '(':
                if right == 0:
                    s_list[i] = ''
                else:
                    right -= 1
        
        return ''.join(s_list)
        
        

类似Remove Invalid Parentheses, Minimum Add to Make Parentheses Valid, Minimum Number of Swaps to Make the String Balanced, Check if a Parentheses String Can Be Valid.

跟上Minimum Insertions to Balance a Parentheses String.