301. 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())()"]
")(" -> [""]

To solve the problem of removing the minimum number of invalid parentheses, we can use a Breadth-First Search (BFS) approach. Here’s the implementation for the removeInvalidParentheses method in Java:

 

Explanation:

1. BFS Traversal:

• We start with the original string and explore all possible strings formed by removing one parenthesis at a time.

• Continue until we find valid strings, at which point we stop further exploration for that level.

2. Valid Parentheses Check:

• Use a helper method to check if a string has valid parentheses based on a counter.

3. De-duplication:

• Use a Set to avoid processing the same string multiple times.

public class Solution {
    public List<String> removeInvalidParentheses(String s) {
        List<String> result = new ArrayList<>();
        if (s == null) return result;

        Set<String> visited = new HashSet<>();
        Queue<String> queue = new LinkedList<>();

        queue.add(s);
        visited.add(s);

        while (!queue.isEmpty()) {
            String current = queue.poll();

            if (isValid(current)) {
                result.add(current);
            }

            if (!result.isEmpty()) continue; 
            // we shouldn't continue to add child nodes, but we need to check the remaining candidates in the queue. 

            for (int i = 0; i < current.length(); i++) {
                if (current.charAt(i) != '(' && current.charAt(i) != ')') continue;

                String next = current.substring(0, i) + current.substring(i + 1);
                if (!visited.contains(next)) {
                    visited.add(next);
                    queue.add(next);
                }
            }
        }

        return result;
    }

    private boolean isValid(String s) {
        int count = 0;
        for (char c : s.toCharArray()) {
            if (c == '(') {
                count++;
            } else if (c == ')') {
                count--;
            }
            if (count < 0) return false;
        }
        return count == 0;
    }
}

 

首先，遍历所有情况，然后看是否最后得到的string是否满足所有valid parentheses的情况，满足的话，就比较已经存在的valid parentheses. 否则就放弃。

public class Solution {
    public List<String> removeInvalidParentheses(String s) {
        List<String> list = new ArrayList<>();
        if (s == null) return list;
        list.add("");
        helper(s, 0, "", 0, list);
        return list;
    }

    void helper(String str, int index, String tempString, int leftCount, List<String> list) {
        if (str.isEmpty() || leftCount > str.length() - index) return;

        if (list.size() != 0 && list.get(0).length() > tempString.length() + str.length() - index) return;

        if (index == str.length()) {
            if (leftCount == 0) {
                if (list.get(0).length() < tempString.length()) {
                    list.clear();
                    list.add(tempString);
                } else if (list.get(0).length() == tempString.length() && !list.contains(tempString)) {
                    list.add(tempString);
                }
            }
            return;
        }

        if (str.charAt(index) == '(') {
            helper(str, index + 1, tempString + "(", leftCount + 1, list);
            helper(str, index + 1, tempString, leftCount, list);
        } else if (str.charAt(index) == ')') {
            if (leftCount != 0) {
                helper(str, index + 1, tempString + ")", leftCount - 1, list);
            }
            helper(str, index + 1, tempString, leftCount, list);
        } else {
            helper(str, index + 1, tempString + str.charAt(index), leftCount, list);
        }
    }
}

 

public class Solution {
    public List<String> removeInvalidParentheses(String s) {
        List<String> res = new ArrayList<String>();
        int[] max = { 0 };
        dfs(s, "", 0, res, max);
        if (res.size() == 0) {
            res.add("");
        }
        return res;
    }

    private void dfs(String str, String subRes, int countLeft, List<String> res, int[] max) {
        if (countLeft > str.length()) return;
        if (str.length() == 0) {
            if (countLeft == 0 && subRes.length() != 0) {
                if (subRes.length() > max[0]) {
                    max[0] = subRes.length(); 
                       res.clear();
                }
                if (max[0] == subRes.length() && !res.contains(subRes)) {
                    res.add(subRes.toString());
                }
            }
            return;
        }

        if (str.charAt(0) == '(') {
            dfs(str.substring(1), subRes + "(", countLeft + 1, res, max);
            dfs(str.substring(1), subRes, countLeft, res, max);
        } else if (str.charAt(0) == ')') {
            if (countLeft > 0) {
                dfs(str.substring(1), subRes + ")", countLeft - 1, res, max);
            }
            dfs(str.substring(1), subRes, countLeft, res, max);
        } else {
            dfs(str.substring(1), subRes + str.charAt(0), countLeft, res, max);
        }
    }
}