LeetCode Top 100 Liked Questions 301. Remove Invalid Parentheses (Java版; Hard)

welcome to my blog

LeetCode Top 100 Liked Questions 301. Remove Invalid Parentheses (Java版; Hard)

题目描述

Remove the minimum number of invalid parentheses in order to make the input string valid. Return all possible results.

Note: The input string may contain letters other than the parentheses ( and ).

Example 1:

Input: "()())()"
Output: ["()()()", "(())()"]
Example 2:

Input: "(a)())()"
Output: ["(a)()()", "(a())()"]
Example 3:

Input: ")("
Output: [""]

第一次做; 有连续的右括号时,删除最靠左的有括号; 明确indexOfLeft和indexOfRight的作用, 从indexOfLeft开始检查check[0], 从indexOfRight开始检查check[1]; 删除check[1]时, indexOfRight的新值必须是j; 这道题确实难, 复习时着重思考注释中的7个核心

/*
核心: 从左到右处理, 从右到左处理
*/
import java.util.List;
import java.util.ArrayList;


class Solution {
    public List<String> removeInvalidParentheses(String s) {
        List<String> res = new ArrayList<>();
        char[] check = new char[]{'(', ')'};
        //核心1:两个0的含义
        dfs(res, check, s, 0, 0);
        return res;
    }
    /*    
    从左往右处理
    从右往左处理
    
    核心2: 同一个方向下, 只处理多出来的check[1]
    
    核心3:
    从indexOfLeft开始检查check[0]
    从indexOfRight开始检查check[1]
    */
    public void dfs(List<String> res, char[] check, String s, int indexOfLeft, int indexOfRight){
        //count = check[0]的数量 - check[1]的数量
        int count=0;
        int i = indexOfLeft;
        // 核心4: count>0意味着很多, 并不是左右括号数量相等就说明有效, 比如"))(("左右括号数量相等但是无效; 遍历过程中要保证count>=0, 这样能保证每一个左括号会对应一个右括号
        while(i<s.length() && count>=0){
            if(s.charAt(i)==check[0])
                count++;
            else if(s.charAt(i)==check[1])
                count--;
            //如果当前字符不是'('也不是')', 不做处理
            //右移
            i++;
        }
        //here, i==s.length() || count < 0
        /*
        i<s.length() && count<0
        check[1]比check[0]多, 需要删掉多余的check[1]
        核心6count<0, 其实count==-1
        */
        if(count<0){
            //核心5: s.charAt(i-1)一定是check[1], 这个check[1]导致了count<0
            for(int j=indexOfRight; j<=i-1; j++){
                //有多个连续的check[1]的话, 只处理最靠左的check[1], 这样就不会出现重复的情况了
                //核心6: 尝试删除不同位置的check[1]会有什么影响? 这将关系到新条件新递归中的indexOfRight的取值
                if(s.charAt(j)==check[1] && (j==indexOfRight || s.charAt(j-1)!=check[1])){
                    //删掉j位置处的check[1]
                    //核心7:indexOfRight的新值取i-1?错!  indexOfRight的新值必须是j, 从上一次删除check[1]的位置的下一个位置开始寻找并删除check[1]; 看绊脚案例就明白了
                    dfs(res, check, s.substring(0,j)+s.substring(j+1), i-1, j);
                }
            }
        }
        /*
        i=s.length() && count>=0; 可能的情况: 从左到右检查完了, 该从右往左检查了; 或者从右往左检查完了, 此时说明两个方向都检查过了, 而且有'('==')'
        */
        else{
            //说明当前从左往右检查完了, 该从右往左检查了
            if(check[0]=='('){
                check = new char[]{')','('};
                s = new StringBuilder(s).reverse().toString();
                dfs(res, check, s, 0, 0);
            }
            //说明当前从右往左检查完了; 注意此时说明两个方向都检查完了,添加结果即可
            else{
                //细节: 再把s翻转回来
                s = new StringBuilder(s).reverse().toString();
                res.add(s);
            }
        }
    }
}

一个案例的递归过程