Remove Invalid Parentheses 解答

Question

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

Solution

看到parenthese的问题，第一反应是用栈。这题要求minimum number，所以想到用BFS遍历解空间树。

思路为：

层次依次为删除0个元素，1个元素，2个元素。。。

层次遍历所有的可能。如果有一种可能是valid，那么不再遍历下面的层。

public class Solution {
    public List<String> removeInvalidParentheses(String s) {
        Set<String> visited = new HashSet<String>();
        List<String> result = new ArrayList<String>();
        List<String> current = new ArrayList<String>();
        List<String> next;
        current.add(s);
        boolean reached = false;
        // BFS
        while (!current.isEmpty()) {
            next = new ArrayList<String>();
            for (String prev : current) {
                visited.add(prev);
                // If valid
                if (isValid(prev)) {
                    reached = true;
                    result.add(prev);
                }
                
                // If not reached, then delete
                if (!reached) {
                    for (int i = 0; i < prev.length(); i++) {
                        char tmp = prev.charAt(i);
                        if (tmp != '(' && tmp != ')') {
                            continue;
                        }
                        String newStr = prev.substring(0, i) + prev.substring(i + 1);
                        if (!visited.contains(newStr)) {
                            next.add(newStr);
                            visited.add(newStr);
                        }
                    }
                }
            }
            if (reached) {
                break;
            }
            current = next;
        }
        return result;
    }
    
    private boolean isValid(String s) {
        Deque<Integer> stack = new LinkedList<Integer>();
        for (int i = 0; i < s.length(); i++) {
            char cur = s.charAt(i);
            if (cur != '(' && cur != ')') {
                continue;
            }
            if (cur == '(') {
                stack.push(i);
            }
            if (cur == ')') {
                if (stack.isEmpty()) {
                    return false;
                } else {
                    stack.pop();
                }
            }
        }
        return stack.isEmpty();
    }
}

事实上，我们可以不用栈，用一个count来检测是否是valid parenthese.

private boolean isValid(String s) {
    int count = 0;
    for (int i = 0; i < s.length(); i++) {
        char cur = s.charAt(i);
        if (cur != '(' && cur != ')') {
            continue;
        }
        if (cur == '(') {
            count++;
        }
        if (cur == ')') {
            count--;
            if (count < 0) {
                return false;
            }
        }
    }
    return count == 0;
}