LeetCode301 删除无效括号

原题目

代码分析

1.dfs

情况分析:
(1)当前为左括号:
删除左括号:左括号删除个数-1,其余不变,继续递归下一位置
保留左括号:栈数+1,其余不变,继续递归下一位置
(2)当前为右括号:
删除右括号:右括号删除个数-1,其余不变,继续递归下一位置
保留右括号:栈数-1,其余不变,继续递归下一位置
(3)当前为其他字符:
直接保存当前字符,其余不变,继续递归下一位置

终止条件:
当左括号和右括号要删除的个数都为零且字符串遍历到最后
说明符合条件,放入结果数组中

如果左括号或右括号要删除的个数小于0(删除的括号多了)或栈数小于0(右括号比左括号多了),不满足条件,直接停止递归,回溯上一层

class Solution {
public:
    vector<string>res;
    map<string,int>m;
    /*
		s 原字符串
		index 当前递归遍历位置
		stack_count 用于判断左括号是否多于右括号
		kl 左括号要删除的个数
		kr 右括号要删除的个数
		temp 临时存储的满足条件的字符串
	*/
    void dfs(string &s, int index, int stack_count, int kl, int  kr, string temp){
        if(index == s.size()){
            if(kl == 0 && kr == 0&&m.find(temp)==m.end()){
                res.push_back(temp);
                m[temp] = 1;
            }
            return;
        }
        
        if(kr < 0 || kl < 0||stack_count<0){
            return;
        }

        if(s[index]=='('){
            dfs(s, index+1, stack_count+1, kl, kr, temp+s[index]);
            dfs(s, index+1, stack_count, kl-1, kr, temp);
        }else if(s[index]==')'){
            dfs(s, index+1, stack_count-1, kl, kr, temp+s[index]);
            dfs(s, index+1, stack_count, kl, kr-1, temp);
        }else{
            dfs(s, index+1, stack_count, kl, kr, temp+s[index]);
        }
    }
    vector<string> removeInvalidParentheses(string s) {
        int max_count =0, stack_count = 0, kl = 0, kr = 0;
        for(auto c : s){
            if(c == '('){
                kl++;
                stack_count++;
            }else if(c == ')'){
                kr++;
                if(stack_count>0){
                   stack_count--;
                   max_count++;
                }
            }
        }
        dfs(s, 0, 0, kl-max_count, kr-max_count, "");
        return res;
    }
};

2.反转

m 表示从 [0, m-1] 这一段都是正常的括号，正常，是指左括号数量比右括号多。 n 表示上一次操作，在这个位置删除了一个右括号。

remove 逻辑，先看一下平凡的思路：

1.从第 0 个位置开始向右扫描，一旦发现右括号多出来了，就必须要删除一个 [0, 当前位置] 的范围的右括号。删除掉后，[0, 当前位置] 就是一个符合条件的括号匹配，继续向右扫描，如果又遇到右括号多出来，再次从 [0, 当前位置] 删除一个右括号，这样直到所有不符合条件的右括号被删除。
2.把第 1 步得到的字符串，反转，按照同样的思路，把多出来的“右括号”（算法一样，只是以前的左括号要当成右括号来处理）删除。
3.经过以上 2 步的处理，最终处理的字符串就是符合要求的。
4.如果按照上面的步骤操作，会产生重复的结果，这里有一些去重的 trick 逻辑，具体看下面的代码和示例分析。

class Solution {
public:
    vector<string> removeInvalidParentheses(string s) {
        vector<string> res;
        remove(move(s), {'(', ')'}, 0, 0, res);
        return res;
    }
    
    void remove(std::string s, const vector<char>& par, int m, int n, vector<string>& res) {
        int stack = 0;
        for (int i = m; i < s.length(); ++i) {
            if (s[i] == par[0]) stack++;
            if (s[i] == par[1]) stack--;
            if (stack >= 0) continue;
            // "右"括号多出来了，删除一个右括号
            for (int j = n; j <= i; ++j) {
                if (s[j] == par[1] && (j == n || s[j-1] != par[1])) {
                    auto ss = s.substr(0, j) + s.substr(j + 1);
                    remove(move(ss), par, i, j, res);
                }
            }
            return;
        }
        
        reverse(s.begin(), s.end());
        if (par[0] == '(') {
            remove(move(s), {par[1], par[0]}, 0, 0, res);
        } else {
            res.push_back(move(s));
        }
    }
};