[leetcode每日一题2021/10/27]301. 删除无效的括号【困难】栈

题目来源于leetcode，解法和思路仅代表个人观点。传送门。
难度： 困难
时间：1h 编程时间

题目

给你一个由若干括号和字母组成的字符串 s ，删除最小数量的无效括号，使得输入的字符串有效。

返回所有可能的结果。答案可以按 任意顺序 返回。

示例 1：

输入：s = "()())()"
输出：["(())()","()()()"]

示例 2：

输入：s = "(a)())()"
输出：["(a())()","(a)()()"]

示例 3：

输入：s = ")("
输出：[""]

提示：
1 <= s.length <= 25
s 由小写英文字母以及括号 '(' 和')' 组成
s 中至多含 20 个括号

思路

题目要求，删除最小数量的无效括号。
那么，只需要删除不匹配的括号即可。

---

理论分析

那么如何确定不匹配的括号？
使用栈，遍历一次字符串s，即可以发现所有不匹配的字符。

这里，不匹配的括号有如下规律。

...)...)...(...(...

其中，'('或者')'表示不匹配的括号。'...'表示匹配的括号()(())... 或字母a、b、c...。

---

我们将s分为三部分，如下所示：

   1   | 2 |   3
-------|---|-------
...)...)...(...(...

• 第一部分，只有')'多余。
• 第二部分，没有多余的括号。
• 第三部分，只有'('多余。

---

在第一部分中，再具体分析一下，

 1   2   3   other
---|---|---|-------
...)...)...).......

如上排列的括号，如何删除才能满足条件（删除最小数量的无效括号）？

答：删除第1部分中，任意1个')'+删除第2部分中，任意1个')'+删除第3部分中，任意1个')'。

即，删除每部分任意1个')'，得到的字符串按顺序组合。

---

第三部分中，实现的逻辑，同第一部分类似。

---

最后，
第一部分的结果+第二部分+第三部分的结果，即为最终答案。

---

具体实现

在代码实现上，我们具体分析一下，

1. 实现函数delete_bracket，删除字符串&s中，任意一个'('或')'。返回所有可能的情况，需要hashset。
2. 使用栈遍历字符串s。

如果当前字符为'('，入栈。

如果当前字符为')'，

• 如果栈不空，出栈一个元素。
• 如果栈空，删除前面一部分中的任意一个')'（调用delete_bracket函数，得到第k部分的结果）。

 1   2   3   other
---|---|---|-------
...)...)...).......

第1部分的结果+第2部分的结果+第3部分的结果
我们使用prefixes数组保存，前面k个删除的情况。（好难表达啊，详细看代码吧）

3. 遍历结束后，栈中剩余的就是不匹配的左括号了。
   方法与2.类似，不过只是从右到左相加。

 other   3   2   1  
-------|---|---|---|
.......|...(...(...(

第1部分的结果+第2部分的结果+第3部分的结果

4. 最后加上中间的部分hashset，就是答案啦。

代码

class Solution {
public:
    unordered_set<string> delete_bracket(string& s,char target){
        /*
        s   -   串
        target  -   '(' or ')'
        */
        //在s中任意删除一个target
        unordered_set<string> ans;
        int n = s.length();
        for(int i=0;i<n;i++){
            if(s[i] != target){
                //跳过其他字符
                continue;
            }
            //删除当前字符
            string rst = s.substr(0,i) + s.substr(i+1,string::npos);
            //加入到答案
            ans.insert(rst);
        }
        return ans;
    }
    vector<string> removeInvalidParentheses(string s) {
        // ...)...)...(...(...
        int left = 0;
        int right = 0;
        int n = s.length();

        vector<string> prefixes = {""};

        stack<int> stk;
        //使用栈实现括号匹配
        for(right = 0;right<n;right++){
            if(s[right] == '('){
                //如果是'('
                //入栈
                stk.push(right);
            }else if(s[right] == ')'){
                //如果是')'
                if(!stk.empty()){
                    stk.pop();
                }else{
                    //当前')'无法匹配
                    //在前面left~right中删除一个')'
                    string sub_s = s.substr(left,right-left+1);
                    
                    auto temp = prefixes; //copy
                    prefixes.clear();

                    for(auto& prefix:temp){
                        //取prefix + [left,right]之间删除一个')'的串
                        string concat_s = prefix+sub_s;
                        auto rst = delete_bracket(concat_s,')');

                        //临时结果保存到下一次
                        for(auto& r:rst){
                            prefixes.push_back(r);
                        }
                    }

                    left = right+1;
                }
            }else{
                //跳过其他字符...
            }
        }//for-

        int non_left = left;    //没有操作的区间

        right = n - 1;
        vector<string> suffixes={""};

        //现在只剩下左括号，代码与')'部分的代码类似
        while(!stk.empty()){
            int left = stk.top();
            stk.pop();

            //在[left,right]之间删除一个左括号
            string sub_s = s.substr(left,right-left+1);

            auto temp = suffixes; // copy
            suffixes.clear();

            for(auto& suffix:temp){
                string concat_s = sub_s + suffix;
                auto rst = delete_bracket(concat_s,'(');

                //保存临时结果
                for(auto& r:rst){
                    suffixes.push_back(r);
                }
            }

            right = left-1;
        }

        int non_right = right; //没有操作的区间

        string inter_s = s.substr(non_left,non_right-non_left+1);
        //整理答案
        vector<string> ans;
        unordered_set<string> sset; //最后结果去重

        int n1 = prefixes.size();
        int n2 = suffixes.size();
        for(int i=0;i<n1;i++){
            for(int j=0;j<n2;j++){
                string a = prefixes[i]+inter_s+suffixes[j];
                if(!sset.count(a)){
                    sset.insert(a);
                    ans.push_back(a);
                }
            }
        }
        return ans;
    }
};

算法复杂度

时间复杂度： $O(n\ast 2^n)$。其中，$n$为字符串长度。$O(2^n)$为删除括号后，可能生成字符串的数量。
空间复杂度： 整不会了，大家看官方题解吧