301. Remove Invalid Parentheses

题目描述

输入：一个字符串，包含(,)，还有一些其他字符。
输出：左右括号完全匹配的字符串。并且要尽可能少的删除字符。
规则：有左括号，有对应的右括号与之匹配，成为有效。

回溯法

分析1：用回溯法/暴力搜索，对于每一位的字符都考虑去掉或者留下两种可能，总会得到结果。这样的话，去掉的字符个数不同，需要记录下来，返回的时候返回删除字符最少的那个。同时还要考虑到可能通过多种途径得到同一个字符串，需要去重。

public class RemoveInvalidParentheses301 {
    //key:去掉了几个字符; value 最后形成的结果
    private Map<Integer,List<String>> map = new HashMap<>();
    private int minDis;
    /**
     * 用回溯法/暴力搜索，挨个去掉或者留下每个字符计算文字的有效性
     * @param s
     * @return
     */
    public List<String> removeInvalidParentheses(String s) {
        minDis = s.length();
        dfs(s,0,new StringBuilder());
        return map.get(minDis);
    }

    private void dfs(String s, int idx,StringBuilder val) {
        if(idx<s.length()){
            if(s.charAt(idx)=='('||s.charAt(idx)==')'){
                //留下第idx个元素
                dfs(s,idx+1,val.append(s.charAt(idx)));
                val.setLength(val.length()-1);
                //去掉第idx个元素
                dfs(s,idx+1,val);
            }else{
                dfs(s,idx+1,val.append(s.charAt(idx)));
                val.setLength(val.length()-1);
            }

        }else{
            //判断val是否有效
            int dis = s.length() - val.length();
            if(dis>minDis){
                return;
            }
            String text = val.toString();
            if(isValidate(text)){
                List<String> results = map.getOrDefault(dis,new ArrayList<>());
                if(!results.contains(text)){
                    results.add(text);
                    map.put(dis,results);
                    minDis = Math.min(minDis,dis);
                }
            }
        }
    }

    private boolean isValidate(String text) {
        int leftSize = 0;
        for(int i=0;i<text.length();i++){
            if(text.charAt(i)=='('){
                leftSize++;
            }else if(text.charAt(i)==')'){
                if(leftSize==0) return false;
                leftSize--;
            }
        }
        return leftSize==0;
    }
}

有效剪枝，速度更快

这个版本的代码基本就是官方的实现。思路和上面一样，但是速度快了很多。原有有几个。
1 判断字符串是否有效，这里通过计数结果中左括号、右括号数量来判断。速度更快。
2 有效剪枝。在leftCount<=rightCount的时候遇到一个)，那肯定是一个无效字符，无需加入到结果集。
3 有效剪枝。在已经删除元素个数removed>minimumRemoved，无需继续递归。

class Solution {
    private Set<String> result;
    private int minimumRemoved;
    public List<String> removeInvalidParentheses(String s) {
        result = new HashSet<String>();
        minimumRemoved = s.length();
        dfs(s,0,0,0,new StringBuilder(),0);
        return new ArrayList<String>(result);
    }
    
    private void dfs(String s,int index,int leftCount,int rightCount,StringBuilder expression,int removed){
        if(removed > minimumRemoved) return;
        if(index == s.length()){
            if(leftCount == rightCount){
                if(removed < minimumRemoved){
                    minimumRemoved = removed;
                    result.clear();
                    result.add(expression.toString());
                }else if(removed == minimumRemoved){
                    result.add(expression.toString());
                }
            }
        }else{
            int length = expression.length();
           //不是括号的时候
           if(s.charAt(index)!='(' && s.charAt(index)!=')'){
               expression.append(s.charAt(index));
               dfs(s,index+1,leftCount,rightCount,expression,removed);
               expression.deleteCharAt(length);
           }else if(s.charAt(index)==')' && leftCount<=rightCount){
               dfs(s,index+1,leftCount,rightCount,expression,removed+1);
           }else{
               dfs(s,index+1,leftCount,rightCount,expression,removed+1);
               expression.append(s.charAt(index));
               if(s.charAt(index)=='('){
                   dfs(s,index+1,leftCount+1,rightCount,expression,removed);
               }else{
                   dfs(s,index+1,leftCount,rightCount+1,expression,removed);
               }
               expression.deleteCharAt(length);               
           }
        }
    }
}

回溯法改进

分析2：也是官方解释。观察所有返回值的长度是相同的。我们需要移除的字符数是一定的。
怎么确定这个数量呢？为了得到有效的字符串，我们应该移除多少个左括号，多少个右括号呢？
1 我们从左开始每次处理一个括号；
2 如果我们遇到了左 括号，它可能回也有可能不会导致一个错误的表达。因为可能在后面会遇到一个关闭的括号。所以我们简单地记录下左括号的痕迹：left +=1；
3 如果我们遇到了右 括号，这会有两种情况。情况1：没有左括号，left=0，这个时候直接right+=1。情况2：还有一些左括号没有匹配到，这个时候left-=1。
4 继续处理，直到字符串结束。
5 最后left 和 right的值告诉我们没有匹配到的左右括号分别有多少个。

public class RemoveInvalidParentheses301_2 {
    private List<String> results = new ArrayList<>();
    public List<String> removeInvalidParentheses(String s) {
        results = new ArrayList<>();
        int len = s.length();
        int left = 0,right = 0;
        for(int i=0;i<len;i++){
            if(s.charAt(i)=='('){
                left++;
            }else if(s.charAt(i)==')'){
                if(left>0){
                    left--;
                }else{
                    right++;
                }

            }
        }

        dfs(s,0,left,right,new StringBuilder());
        return results;
    }

    private void dfs(String s, int idx, int left, int right, StringBuilder val) {
        if(left<0 || right<0) return;
        if(idx==s.length()){
            String text = val.toString();
            if(left==0 && right==0 && isValidate(text)){
                if(!results.contains(text)){
                    results.add(text);
                }
            }
        }else{
            int len = val.length();
            if(s.charAt(idx)=='('){
                //去掉
                dfs(s,idx+1,left-1,right,val);
                val.append(s.charAt(idx));
                dfs(s,idx+1,left,right,val);
            }else if(s.charAt(idx)==')'){
                dfs(s,idx+1,left,right-1,val);
                val.append(s.charAt(idx));
                dfs(s,idx+1,left,right,val);
            }else{
                val.append(s.charAt(idx));
                dfs(s,idx+1,left,right,val);
            }
            val.setLength(len);
        }
    }

    private boolean isValidate(String text) {
        int leftSize = 0;
        for(int i=0;i<text.length();i++){
            if(text.charAt(i)=='('){
                leftSize++;
            }else if(text.charAt(i)==')'){
                if(leftSize==0) return false;
                leftSize--;
            }
        }
        return leftSize==0;
    }
}