【NO.77】LeetCode HOT 100—301. 删除无效的括号

301. 删除无效的括号

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

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

示例 1：

输入：s = “()())()”
输出：[“(())()”,“()()()”]
示例 2：

输入：s = “(a)())()”
输出：[“(a())()”,“(a)()()”]
示例 3：

输入：s = “)(”
输出：[“”]

提示：

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

解题

方法一：回溯

题意让我们删除括号使得剩下的括号匹配，要求我们删除最少的括号数，并且要求得到所有的结果。我们可以使用回溯算法，尝试遍历所有可能的去掉非法括号的方案。

可以先统计出左括号的数量和右括号的数量，然后利用括号匹配的规则，计算出要最少删除的左括号和右括号的数量，然后我们尝试在原字符串 s 中去掉该数量的左括号和右括号，然后检测剩余的字符串是否合法匹配，如果合法匹配则我们则认为该字符串为可能的结果。

// 时间 O(n * 2^n) , 其中 n 为字符串的长度。考虑到一个字符串最多可能有 2^n个子序列，每个子序列可能需要进行一次合法性检测 
// 空间O(n^2), 递归 调用栈的深度
class Solution {   
    // 存放结果
    List<String> ans = new ArrayList<>();

    public List<String> removeInvalidParentheses(String s) {
        // 记录要删除的左括号、右括号的数量
        int lremove = 0;
        int rremove = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '(') {
                lremove++;
            } else if (s.charAt(i) == ')') {
                if (lremove == 0) {
                    // 右括号数量多了
                    rremove++;
                } else {
                    lremove--;
                }
            }
        }        

        // 深度优先搜索 字符串（开始回溯）
        handle(s, 0, lremove, rremove);
        return ans;
    }

    private void handle(String s, int index, int lremove, int rremove) {
        if (lremove == 0 && rremove == 0) {
            if (isValid(s)) {
                ans.add(s);
            }
        }

        // 开始从index位置遍历字符串
        for (int i = index; i < s.length(); i++) {
            // 剪枝,连续相同的括号，减去一个就行了，其他的都是相同的结果
            if (i != index && s.charAt(i) == s.charAt(i-1)) {
                continue;
            }
            // 剪枝，如果剩下的字符不够减的，直接返回
            if (lremove+rremove > s.length() - i) {
                return;
            }
            // 删括号
            if (lremove > 0 && s.charAt(i) =='(') {
                handle(s.substring(0,i) + s.substring(i+1), i, lremove-1, rremove);
            }
            if (rremove > 0 && s.charAt(i) ==')') {
                handle(s.substring(0,i) + s.substring(i+1), i, lremove, rremove-1);
            }
        }
    }

    // 判断字符串是否是有效的括号字符
    private boolean isValid(String s) {
        int count = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '(') {
                count++;
            } else if (s.charAt(i) == ')') {
                count--;
                if (count < 0) {
                    return false;
                }
            }
        }
        return count == 0;
    }
}

方法二：BFS（广度优先搜索）

题目中要求最少删除，这样的描述正是广度优先搜索算法应用的场景，并且题目也要求我们输出所有的结果。我们在进行广度优先搜索时每一轮删除字符串中的 1 个括号，直到出现合法匹配的字符串为止，此时进行轮转的次数即为最少需要删除括号的个数。

我们进行广度优先搜索时，每次保存上一轮搜索的结果，然后对上一轮已经保存的结果中的每一个字符串尝试所有可能的删除一个括号的方法，然后将保存的结果进行下一轮搜索。在保存结果时，我们可以利用哈希表对上一轮生成的结果去重，从而提高效率。

// 时间复杂度：O(n×2^n)，其中 n 为字符串的长度。考虑到一个字符串最多可能有 2^n个子序列.

//空间复杂度：O(n×Cn/2 n)，其中 n 为字符串的长度。我们在进行第 i 轮迭代时，会从原始字符串中删除 i 个括号，因此第 i 轮迭代产生的字符串最多有 Ci n个，当 i=n/2时组合数最大，此时迭代生成的字符串个数最多，因此空间复杂度为 O(n×C n/2  n)。
class Solution {

    public List<String> removeInvalidParentheses(String s) {
        // 存放结果
        List<String> ans = new ArrayList<>();
        HashSet<String> curStrSet = new HashSet<>();
        curStrSet.add(s);
        while (true) {
            // 把集合中有效的字符串放进结果里
            for (String str : curStrSet) {
                if (isValid(str)) {
                    ans.add(str);
                }
            }
            // 最少删除，已经有结果了，直接返回
            if (ans.size() > 0) {
                return ans;
            }
            // 对当前set集合里的每个字符串尝试删除一个括号
            HashSet<String> nextStrSet = new HashSet<>();
            for (String str : curStrSet) {
                for (int i = 0; i < str.length(); i++) {
                    // 多个相同的括号，删除一个即可
                    if (i > 0 && str.charAt(i) == str.charAt(i-1)) {
                        continue;
                    }
                    // 删除遇到的第一个括号
                    if (str.charAt(i) == '(' || str.charAt(i) == ')') {
                        nextStrSet.add(str.substring(0,i) + str.substring(i+1));
                    }
                }
            }

            curStrSet = nextStrSet;
        }
        
    }


    // 判断字符串是否是有效的括号字符
    private boolean isValid(String s) {
        int count = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '(') {
                count++;
            } else if (s.charAt(i) == ')') {
                count--;
                if (count < 0) {
                    return false;
                }
            }
        }
        return count == 0;
    }
}