leetcode301.删除无效的括号（困难）

自己的思路：用2进制模拟dfs，然而这样的复杂度是2^n * n，会超时。。。

解法一：对上面的dfs做优化。
具体思路：先分别计算出左括号和右括号需要删除的个数。然后用dfs，参数中记录剩下需要删除的个数，如果个数大于0才删除。

class Solution {
public:
    vector<string> ans;
    void dfs(string s, int index, int left, int right) {
        if (s.size() - index < left + right) return ; //
        if (!left && !right) { 
            if (judge(s)) ans.push_back(s);
            return ;
        }
        for (int i = index; i < s.size(); ++i) { 
            if (i != index && s[i] == s[i - 1]) continue;//
            if (s[i] == '(' && left > 0) dfs(s.substr(0, i) + s.substr(i + 1), i, left - 1, right); // //
            if (s[i] == ')' && right > 0) dfs(s.substr(0, i) + s.substr(i + 1), i, left, right - 1);
        }
    }
    bool judge(string s) {
       int l = 0, r = 0, n = s.size();
        //if (n & 1) return false;
        for (auto& each : s) {
            if (each == '(') l++;
            if (each == ')') r++;
            if (r > l || l > n / 2) return false; 
        }
        return (l == r) ? true : false;
    }
    vector<string> removeInvalidParentheses(string s) {
        
        int left_cnt = 0, right_cnt = 0; 
        for (auto& each : s) {
            if (each == '(') left_cnt++;
            if (each == ')' && !left_cnt) right_cnt++;
            if (each == ')' && left_cnt) left_cnt--;
        }
        dfs(s, 0, left_cnt, right_cnt);
        return ans;
    }
};

分别计算左括号和右括号需要删除的个数的思路：

int left_cnt = 0, right_cnt = 0; 
for (auto& each : s) {
    if (each == '(') left_cnt++;
    if (each == ')' && !left_cnt) right_cnt++;
    if (each == ')' && left_cnt) left_cnt--;
}

代码上的难点：
1：如果剩下的字符个数小于需要删除的个数，则进行剪枝

if (s.size() - index < left + right) return ; 

2：在每层的dfs中，只删除一个字符，如有多个相邻，只删除一个就可以，所以加下面的代码：

if (i != index && s[i] == s[i - 1]) continue; //只删除第一个，后面一样的直接跳过

3：下标的控制，在下一层的时候从该层删除的下标开始遍历

dfs(s.substr(0, i) + s.substr(i + 1), i, left - 1, right); //下一层用i作为参数

4：删除str中i下标的字符：

s.substr(0, i) + s.substr(i + 1) //用substr

5：由于序列中用字母，所以不能用括号序列的奇偶来判断

//if (n & 1) return false;

解法二：看到求最少的个数，自然想到bfs
具体思路：依次一个字符，两个字符…直到某一层出现了一个有效的括号序列。

class Solution {
public:
    bool judge(string s) {
       int l = 0, r = 0, n = s.size();
        //if (n & 1) return false;
        for (auto& each : s) {
            if (each == '(') l++;
            if (each == ')') r++;
            if (r > l || l > n / 2) return false; 
        }
        return (l == r) ? true : false;
    }
    vector<string> removeInvalidParentheses(string s) {
        
        vector<string> ans;
        queue<string> q;
        unordered_set<string> ust;
        q.push(s);
        int len = 1, layer = 0, flag = 0;
        while (!flag) {
            for (int i = 0; i < len; ++i) {
                string tmp = q.front();
                q.pop();
                if (judge(tmp)) {
                    flag = 1;
                    ans.push_back(tmp);
                }
                for (int i = 0; i < tmp.size() && !flag; ++ i) {
                	if (i != 0 && tmp[i] == tmp[i - 1]) continue; //
                    string tmp2 = tmp.substr(0, i) + tmp.substr(i + 1);
                    if (!ust.count(tmp2)) {
                        q.push(tmp2);
                        ust.insert(tmp2);
                    }
                }
            }
            len = q.size();
        }
        return ans;
    }
};

思路上的优化
1：用hash记录放入queue中的字符串，避免重复放入，降低时间复杂度
2：在放入下一层的字符串时，如果删除的字符一样，就直接continue

if (i != 0 && tmp[i] == tmp[i - 1]) continue; //加这句