連結：https://leetcode-cn.com/problems/remove-invalid-parentheses/

題目

給你一個由若干括號和字母組成的字串 s ，刪除最小數量的無效括號，使得輸入的字串有效。

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

用例

示例 1：

輸入：s = "()())()"
輸出：["(())()","()()()"]
示例 2：

輸入：s = "(a)())()"
輸出：["(a())()","(a)()()"]
示例 3：

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

思路

方法一
dfs回溯
遍歷記錄需要刪除的左括號和右括號的數量
如果為左括號 left++
如果為右括號 當left>0時 left--
left<0時 說明右括號不匹配 right++
然後回溯刪除括號

class Solution {
public:
    vector<string> removeInvalidParentheses(string s) {
        int left=0,right=0;
        for(auto ss:s){
            if(ss=='('){
                left++;
            }else if(ss==')'){
                if(left>0){
                    left--;
                }else{
                    right++;
                }
            }
        }
        string son;
        backtracking(s,0,left,right,son);
        return vector<string>(ans.begin(),ans.end());

    }
private:
    stack<int>st;
    unordered_set<string>ans;
    void backtracking(string &s,int index,int left,int right,string &sonans){
        if(index==s.size()){
            if(left==0&&right==0){
                for(auto ss:sonans){
                    if(ss=='(')left++;
                    else if(ss==')'){
                        if(left>0)left--;
                        else right++;
                    }
                }
                if(left==0&&right==0)
                    ans.insert(sonans);
            }
            return;
        }
        if(s[index]=='('&&left>0){
            left--;
            backtracking(s,index+1,left,right,sonans);
            left++;
        }else if(s[index]==')'&&right>0){
            right--;
            backtracking(s,index+1,left,right,sonans);
            right++;
        }
        sonans+=s[index];
        backtracking(s,index+1,left,right,sonans);
        sonans.pop_back();
    }
};
 

實際上可以繼續剪枝
當回溯過程鍾每次都檢查當前序列括號是否匹配

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, 0, 0, lremove, rremove);
        return res;
    }

    void helper(string str, int start, int lcount, int rcount, 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, lcount, rcount, lremove - 1, rremove);
            }
            // 嘗試去掉一個右括號
            if (rremove > 0 && str[i] == ')') {
                helper(str.substr(0, i) + str.substr(i + 1), i, lcount, rcount, lremove, rremove - 1);
            }
            if (str[i] == ')') {
                lcount++;
            } else if (str[i] == ')') {
                rcount++;
            }
            // 當前右括號的數量大於左括號的數量則為非法,直接返回.
            if (rcount > lcount) {
                break;
            }
        }
    }

    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;
    }
};
 

方法二
bfs
要求最少刪除
可以每一輪刪除一個括號，知道出現合法字串為止 出現的這輪即為最小刪除次數，用hash表去重

class Solution {
public:
    bool isValid(string str){
        int count=0;
        for(auto s:str){
            if(s=='(')count++;
            else if(s==')'){
                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.push_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;
        }
    }  
};