移除无效括号

题目

（1）给你一个由 ‘(’、’)’ 和小写字母组成的字符串 s。
（2）你需要从字符串中删除最少数目的 ‘(’ 或者 ‘)’ （可以删除任意位置的括号)，使得剩下的「括号字符串」有效。请返回任意一个合法字符串。
（3）有效「括号字符串」应当符合以下 任意一条 要求：

• 空字符串或只包含小写字母的字符串。
• 可以被写作 AB（A 连接 B）的字符串，其中 A 和 B 都是有效「括号字符串」。
• 可以被写作 (A) 的字符串，其中 A 是一个有效的「括号字符串」。

（4）示例如下
输入：s = “lee(t©o)de)”
输出：“lee(t©o)de”
解释：“lee(t(co)de)” , “lee(t©ode)” 也是一个可行答案。

解决思路

• 思路1：用栈结构解决，当遇到左括号时入栈，当遇到右括号时出栈。在栈结构中能被抵消的括号都是有效的括号，不能被抵消的括号都是无效的括号。
• 思路2：用左右括号差解决，第一遍从左到右遍历字符串，去掉多余的右括号。第二遍遍历，在第一次遍历的结果上从右到左遍历，去掉多余的左括号。然后返回两遍遍历后的结果。

代码

• C++代码

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

using namespace std;

class Solution {
public:
    string minRemoveToMakeValid(string s) {
        // 说明：用char指针存储字符串比直接用string效率高，因为直接操作string涉及到大量拷贝操作，降低效率。

        char* t = new char[s.size() + 1];   // 中间结果，用char类型的指针存储字符串，字符串以'\0'结尾，因此分配的空间大小为s.size() + 1
        char* answer = new char[s.size() + 1]; 
        int tlen = 0;   // 记录第一遍遍历，去掉字符串中无效的右括号后，存储在t中的字符的长度。
        int cnt = 0;    // 记录左括号与右括号的差值。

        // 第一遍遍历,从左到右遍历s，去掉多于的右括号,并将结果存储在 t 对应的内存中。
        for (int i = 0; i < s.size(); i++) {
            if ('(' == s[i] || ')' != s[i]) {
                t[tlen++] = s[i];
                cnt += ('(' == s[i]);    // s[i]为左括号，cant加1
            } else {    // s[i] == ')'的情形
                // 当cnt=0时，即使s[i]是右括号也跳过，从而去掉多余的右括号
                if (0 == cnt) {
                    continue;
                }
                t[tlen++] = s[i];    // 此时s[i]=')'
                cnt -= 1;           // s[i]为右括号，cant减1
            }
        }

        cnt = 0;                // 记录右括号与左括号的差值
        answer[tlen] = '\0';    // 字符串以'\0'结束，先将ans的最后一个字符设置为'\0'。
        int ans_head = tlen;    // 记录最终答案的第一个字符对应的偏移位置。

        // 第二遍遍历，在第一次遍历的结果上，从右到左遍历，去掉多余的左括号，并将结果保存在answer对应的内存中。
        for (int i = tlen - 1; i >= 0; i--) {
            if (')' == t[i] || '(' != t[i]) {
                answer[--ans_head] = t[i];
                cnt += (')' == t[i]);   // t[i]为右括号，cant加1
            } else {        // t[i] == '('的情形
                // 当cnt=0时，即使t[i]是左括号也跳过，从而去掉多余的左括号
                if (0 == cnt) {
                    continue;
                }
                answer[--ans_head] = t[i];      // 此时t[i]='('
                cnt -= 1;       // t[i]为左括号，cant减1
            }
        }
        // ans_head是最终答案的第一个字符的偏移位置，即从ans_head开始到结束的字符才是正确答案。
        // 将char指针指向的内存中的字符转换为字符串。
        return string(answer + ans_head);
    }
};


int main() {
    Solution *solution = new Solution();
    string s = "lee(t(c)o)de)";
    printf("%s\n", solution->minRemoveToMakeValid(s).c_str());      // 注意要使用c_str()
    return 0;
}

• Python代码

# -*- coding: utf-8 -*-

from typing import List


class Solution:
    def minRemoveToMakeValid(self, s: str) -> str:
        tmp: List[str] = []     # 存储中间结果，存储第一遍遍历去掉多于的右括号后的结果
        answer: List[str] = []
        cnt: int = 0

        # 第一遍遍历,从左到右遍历s，去掉多于的右括号,并将结果存储在 t 对应的内存中。
        for i in s:
            if '(' == i or ')' != i:
                cnt += ('(' == i)   # 当前元素为左括号时，cant加1
                tmp.append(i)
            else:       # i == ')'的情形
                if 0 == cnt:    # 当cnt=0时，即使i是右括号也跳过，从而去掉多余的右括号
                    continue
                cnt -= 1        # 当前元素为右括号，cant减1
                tmp.append(i)   # 此时i=')'

        cnt = 0     # 记录右括号与左括号的差值
        # 第二遍遍历，在第一次遍历的结果上，从右到左遍历，去掉多余的左括号，并将结果保存在answer中。
        for j in reversed(tmp):
            if ')' == j or '(' != j:
                cnt += (')' == j)   # 当前元素为右括号，cant加1
                answer.append(j)
            else:       # j == '('的情形
                if 0 == cnt:
                    continue
                cnt -= 1    # # 当前元素为左括号，cant减1
                answer.append(j)    # 此时j='('

        # 第二次遍历时，对tmp进行了反转，因此要对answer进行一次反转。
        answer.reverse()

        return "".join(answer)  # 将List中的值转换为字符串并返回结果


def main():
    solution = Solution()
    s = "lee(t(c)o)de)"
    print(solution.minRemoveToMakeValid(s))


if __name__ == "__main__":
    main()

说明

• 对应LeetCode第1249题。
• 链接：https://leetcode-cn.com/problems/minimum-remove-to-make-valid-parentheses/