LeetCode-301-删除无效的括号

1、回溯

我们可以使用两个变量来分别记录左右括号的个数。每当我们在字符串中读入一个左括号时，我们给左括号的数量加一；当我们在字符串中读入一个右括号时，我们分两种情况进行讨论：1、当此时左括号的个数不为零时，我们直接将左括号的个数减一；2、当此时左括号个数为0时，我们给右括号的个数加一。通过这种方法，我们可以确定必须删除的左右括号的个数。

确定需要删除的括号个数之后，我们需要确定哪些括号是可以删除的。因此我们可以遍历整个字符串进行搜索，利用lremove和rremove记录分别要删除的左右括号的个数。我们在递归遍历所有可能时对一些特殊情况进行剪枝处理：1、当读入位置为左括号时，我们将lremove减一并从原先的字符串中删除对应位置的左括号，继续递归调用该函数；2、当读入为之为右括号时，我们将rremove减一并从原先的字符串中删除对应位置的右括号，继续递归调用该函数；3、当我们遍历整个数组时，若出现连续多个括号待删除，此时虽然有多种删除不同括号的方案，但删除后的结果都是一致的，故我们可以跳过这些情况继续搜索；4、当待删除的左右括号个数大于剩余的字符串长度时，说明当前的删除方案不可行，直接剪枝；5、当lremove和rremove都等于0时，我们检查当前字符串的括号是否是有效的，若有效说明当前方案可行并将结果压入最终答案中。

class Solution {
public:
    vector<string> res;
    vector<string> removeInvalidParentheses(string s) {
        int lremove = 0;
        int rremove = 0;

        for (char c : s) {
            if (c == '(') {
                lremove++;
            } else if (c == ')') {
                if (lremove == 0) {
                    rremove++;
                } else {
                    lremove--;
                }
            }
        }
        helper(s, 0, lremove, rremove);
        return res;
    }

    void helper(string str, int start, int lremove, int rremove) {
        if (lremove == 0 && rremove == 0) {
            if (isValid(str)) {
                res.push_back(str);
            }
            return;
        }
        for (int i = start; i < str.size(); i++) {
            if (i != start && str[i] == str[i - 1]) {
                continue;
            }
            if (lremove + rremove > str.size() - i) {
                return;
            } 
            if (lremove > 0 && str[i] == '(') {
                helper(str.substr(0, i) + str.substr(i + 1), i, lremove - 1, rremove);
            }
            if (rremove > 0 && str[i] == ')') {
                helper(str.substr(0, i) + str.substr(i + 1), i, lremove, rremove - 1);
            }
        }
    }

    inline bool isValid(const string & str) {
        int cnt = 0;
        for (int i = 0; i < str.size(); i++) {
            if (str[i] == '(') {
                cnt++;
            } else if (str[i] == ')') {
                cnt--;
                if (cnt < 0) {
                    return false;
                }
            }
        }
        return cnt == 0;
    }
};

2、广度优先搜索

我们可以将搜索过程理解为对一棵树进行搜索，树上的每一个节点是原先字符串中删除若干个括号后的字符串，每一层之间相差一个括号。这样当我们对整棵树进行广度优先搜索时，因为我们寻找的是删除最少括号数的字符串，因此所有结果都会在同一层中查询到。

当我们在进行广度遍历的时候，我们可以使用哈希集合来记录所有可能的字符串集合，这样做的好处是能够避免出现相同的字符串从而减少不必要的查询。我们在遍历时需要保存上一层搜索的结果，并记录当前层的结果，在当前层查询完成时进行更新。

class Solution {
public:
    bool isValid(string str) {
        int count = 0;

        for (char c : str) {
            if (c == '(') {
                count++;
            } else if (c == ')') {
                count--;
                if (count < 0) {
                    return false;
                }
            }
        }

        return count == 0;
    }

    vector<string> removeInvalidParentheses(string s) {
        vector<string> ans;
        unordered_set<string> currSet;

        currSet.insert(s);
        while (true) {
            for (auto & str : currSet) {
                if (isValid(str))
                    ans.emplace_back(str);
            }
            if (ans.size() > 0) {
                return ans;
            }
            unordered_set<string> nextSet;
            for (auto & str : currSet) {
                for (int i = 0; i < str.size(); i++) {
                    if (i > 0 && str[i] == str[i - 1]) {
                        continue;
                    }
                    if (str[i] == '(' || str[i] == ')') {
                        nextSet.insert(str.substr(0, i) + str.substr(i + 1, str.size()));
                    }
                }
            }
            currSet = nextSet;
        }
    }
};