Leetcode: Remove Invalid Parentheses

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 ).

Examples:
"()())()" -> ["()()()", "(())()"]
"(a)())()" -> ["(a)()()", "(a())()"]
")(" -> [""]

DFS solution with optimizations:

1. Before starting DFS, calculate the total numbers of opening and closing parentheses that need to be removed in the final solution, then these two numbers could be used to speed up the DFS process.
2. Use while loop to avoid duplicate result in DFS, instead of using HashSet.
3. Use count variable to validate the parentheses dynamically.

openN and closeN means the total numbers of opening and closing parentheses that need to be removed in the final solution (removed the minimum number of invalid parentheses).

diff means in the stringbuffer we build, #of '(' minus # of ')'. If at some recursion, diff<0. that's not valid expression, should directly return.

This diff here is not just for pruning, but also have the important meaning to make sure that stringbuffer is always correct. So we must have a diff in the recursion

sb.append(arr, cur, i);

dfs(s, cur + i, diff + i, openN, closeN, res, sb) means not to remove the current parenthesis, keep it in stringbuffer sb.

dfs(s, cur + 1, diff, openN - 1, closeN, result, sb) means to remove the current parenthesis. We won't need to do the dfs if openN has been decreased to zero - if the openN is zero, that means there are already enough open parentheses has been removed, and continually removing open parenthesis won't be a possible solution.

Watch out for duplicate. If red means keep in stringbuffer and white means remove, then the following case are duplicate: 

1. ( ( )

2. ( ( )

3. ( ( )

So our strategy is as 45 and 58 line shows: if you choose to keep one parenthese, then you have to keep all the following same parentheses

for the above cases, we only have 

1. ( ( )

2. ( )

public class Solution {
    public List<String> removeInvalidParentheses(String s) {
        List<String> res = new ArrayList<String>();
        if (s==null || s.length()==0)  {
            res.add("");
            return res;
        }
        int diff=0, openN=0, closeN=0; 
        char[] arr = s.toCharArray();
        for (int i=0; i<arr.length; i++) {
            if (arr[i] == '(') diff++;
            else if (arr[i] == ')') {
                if (diff == 0) closeN++;
                else diff--;
            }
        }
        openN = diff;
        diff = 0;
        if (openN==0 && closeN==0) {
            res.add(s);
            return res;
        }
        
        //backtracking
        dfs(arr, res, 0, diff, openN, closeN, new StringBuffer());
        return res;
    }
    
    public void dfs(char[] arr, List<String> res, int cur, int diff, int openN, int closeN, StringBuffer sb) {
        if (diff < 0) return;
        if (cur == arr.length) {
            if (openN==0 && closeN==0) {
                res.add(sb.toString());
            }
            return;
        }
        if (arr[cur]!='(' && arr[cur]!=')') {
            sb.append(arr[cur]);
            dfs(arr, res, cur+1, diff, openN, closeN, sb);
            sb.deleteCharAt(sb.length()-1);
        }
        else if (arr[cur] == '(') {
            //choice one: keep this '(' in stringbuffer, but in order to avoid duplicate, has to keep all consecutive '('
            int i=0;
            while (cur+i<arr.length && arr[cur+i]=='(') {
                i++;
                sb.append('(');
            }
            dfs(arr, res, cur+i, diff+i, openN, closeN, sb);
            sb.delete(sb.length()-i, sb.length());
            
            //choice two: remove this '(' in stringbuffer
            if (openN > 0) {
                dfs(arr, res, cur+1, diff, openN-1, closeN, sb);
            }
        }
        else if (arr[cur] == ')') {
            //choice one: keep this ')' in stringbuffer, but in order to avoid duplicate, has to keep all consecutive ')'
            int i=0;
            while (cur+i<arr.length && arr[cur+i]==')') {
                i++;
                sb.append(')');
            }
            dfs(arr, res, cur+i, diff-i, openN, closeN, sb);
            sb.delete(sb.length()-i, sb.length());
            
            //choice two: remove this ')' in stringbuffer
            if (closeN > 0) {
                dfs(arr, res, cur+1, diff, openN, closeN-1, sb);
            }
        }
    }
    
}