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;
 }