301. Remove Invalid Parentheses

最新推荐文章于 2020-04-20 22:50:06 发布

无差别刷题

最新推荐文章于 2020-04-20 22:50:06 发布

阅读量402

点赞数

文章标签： dfs backtracking leetcode string bfs

本文链接：https://blog.csdn.net/wilzxu/article/details/88653817

版权

301. Remove Invalid Parentheses

方法1: backtracking/dfs
- 易错点
方法2: bfs

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: [""]

方法1: backtracking/dfs

花花酱：https://www.youtube.com/watch?v=2k_rS_u6EBk

在这里插入图片描述

思路：

遍历第一遍统计有多少个非法的“(”，以及非法的“)”，赋值为 l 和 r，也就是交给dfs需要删除的括号数量。
开始dfs。在dfs的过程中，退出条件是l = 0 && r == 0，此时可以合法推入一个结果。如果还没有删完，需要遍历字串，尝试删除一个"(“或”)"（看哪个还需要）。这个过程中可以用到技巧剪枝：1. 如果当前的i不是"(“或”)"，可以跳过， 2，对于有多种删除选择但是导致的结果相同时，我们选择跳过。这种情况仅发生在类似“())”或"((" 这种情况，也就是出现多个重复的左右括号。那么为了减掉这些可以通过 if (i != start && s[i] == s[i - 1]) continue。start是每次dfs传递进来的string需要开始尝试删除的位置。为什么记录这个呢？因为这个值之前的字符如果需要我们都已经尝试过删除了，再从头开始会产生很多重复计算。而且利用这个数字也可以来去重。删除的操作是s.erase(i, 1)去掉这个字符。注意这时的start就会移交给 i，因为之前的我们也在本循环内都递归删除过了。

易错点

统计非法括号的子函数易错：如果用下面列的第二种累计cnt的方法，cnt不应该出现< -1，因为)))(((，右边的（没有immunity。
统计合法的时候（两次都包括）不要粗暴的else if，因为还可能有其他字符，要检查确实是“(”或者")"。
这里的dfs不要用&，或者像下面的方法一样用&但是单独拷贝出一个current，因为要定点再恢复current不太容易。
start的传递：移交给 i。
理解为什么要给一个start：为了避免重复尝试，并且这个start是指的current的start，每一次remove过之后原地传下去都不用+1。

class Solution {
public:
    vector<string> removeInvalidParentheses(string s) {
        int l = 0, r = 0;
        for (char c: s){
            if (c == '('){
                l++;
            }
            else if (l <= 0 && c == ')'){
                r++;
            }
            else if (c == ')'){
                l--;
            }
        }
        vector<string> result;
        dfs(s, 0, result, l, r);
        return result;
    }
    
    void dfs(string  s, int start, vector<string> & result, int l, int r){
        if (l == 0 && r == 0){
            if (isValid(s)){
                result.push_back(s);
                return;
            }
            
        }
        
        for (int i = start; i < s.size(); i++){
            if (i != start && s[i] == s[i - 1]) continue;
            if (s[i] == '(' || s[i] == ')'){
                string current = s;
                current.erase(i, 1);
                if (r > 0 && s[i] == ')'){
                    dfs(current, i, result, l, r - 1);
                }
                if (l > 0 && s[i] == '('){
                    dfs(current, i, result, l - 1, r);
                }
            }
        }
        return;
    }
    
    bool isValid(string & t){
        int count = 0;
        for (char c: t){
            if (c == '('){
                count++;
            }
            if (c == ')'){
                count--;
            }
            if (count < 0) return false;
        }
        return count == 0;
    }
};
// l = 0, r = 1
// "(   a   )   (   )   )   (   )"
//          i
// start = 0

class Solution {
public:
    vector<string> removeInvalidParentheses(string s) {
        // find left(invalid), right(invalid)
        int left = 0, right = 0, cnt = 0;
        for (char c: s) {
            if (c == '(') {
                ++cnt;
            }
            else if (c == ')') {
            // 只有当cnt == 0 的时候
                if (cnt == 0) right++;
                else cnt--;
            }
        }
        left = cnt > 0 ? cnt: 0;
	}
};


class Solution {
public:
    vector<string> removeInvalidParentheses(string s) {
        vector<string> res;
        // number of invalid left or right
        int l = 0, r = 0;
        for (char c: s) {
            if (c == '(') l++;
            else if (c == ')' && l > 0) l--; 
            else if (c == ')' && l == 0) r++;
        }
        
        // try to remove
        dfs(s, 0, l, r, res);
        return res;
    }
    
    void dfs(string s, int start, int left, int right, vector<string> & res) {
        if (left == 0 && right == 0) {
            if (isValid(s)) {
                res.push_back(s);
            }
        }
        if (start == s.size()) return;    
        
        for (int i = start; i < s.size(); i++) {
            if (i > 0 && s[i] == s[i - 1]) continue;
            string current = s;
            current.erase(current.begin() + i);
            if (s[i] == '(') dfs(current, i, left - 1, right, res);
            else if (s[i] == ')') dfs(current, i, left, right - 1, res);
        }
        return;
    }
    
    bool isValid(string & s) {
        int count = 0;
        for (char c: s) {
            if (c == '(') count++;
            else if (c == ')' && --count < 0) return false;
        }
        return count == 0;
    }
};

discussion：https://leetcode.com/problems/remove-invalid-parentheses/discuss/75050/My-C++-DFS-Solution-16ms
在累计path的时候就记录一个path的变量，追加括号的时候记录一下1或-1。最后在推入之前只需要满足left == 0 , right == 0, pair == 0，不用再查一遍。那么每次递归的时候分为如下几种情况考虑：1. 如果不是括号, left不变，right不变，pair不变，index + 1，path不变。2. 如果是"("，检查是否left > 0 （非法左还没有去除完），如果是, left - 1, right, pair + 1, indext + 1, path, 如果left = 0 left, right, pair, index + 1, path + “(”。3. 如果是“）”，检查是否right > 0 （非法右括号还没有用完），如果是，left, right - 1, pair, index + 1, path, 如果不是，也不能直接添加，要检查pair > 0 才能 left, right, pair - 1, index + 1, path + “)”。

class Solution {
public:
    vector<string> removeInvalidParentheses(string s) {
        unordered_set<string> result;
        int left_removed = 0;
        int right_removed = 0;
        for(auto c : s) {
            if(c == '(') {
                ++left_removed;
            }
            if(c == ')') {
                if(left_removed != 0) {
                    --left_removed;
                }
                else {
                    ++right_removed;
                }
            }
        }
        helper(s, 0, left_removed, right_removed, 0, "", result);
        return vector<string>(result.begin(), result.end());
    }
private:
    void helper(string s, int index, int left_removed, int right_removed, int pair, string path, unordered_set<string>& result) {
        if(index == s.size()) {
            if(left_removed == 0 && right_removed == 0 && pair == 0) {
                result.insert(path);
            }
            return;
        }
        if(s[index] != '(' && s[index] != ')') {
            helper(s, index + 1, left_removed, right_removed, pair, path + s[index], result);
        }
        else {
            if(s[index] == '(') {
                if(left_removed > 0) {
                    helper(s, index + 1, left_removed - 1, right_removed, pair, path, result);
                }
                helper(s, index + 1, left_removed, right_removed, pair + 1, path + s[index], result);
            }
            if(s[index] == ')') {
                if(right_removed > 0) {
                    helper(s, index + 1, left_removed, right_removed - 1, pair, path, result);
                }
                if(pair > 0) {
                    helper(s, index + 1, left_removed, right_removed, pair - 1, path + s[index], result);
                }
            }
        }
    }
};

方法2: bfs

grandyang: http://www.cnblogs.com/grandyang/p/4944875.html

无差别刷题

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
301. Remove Invalid Parentheses

301. Remove Invalid Parentheses方法1: backtracking易错点Remove the minimum number of invalid parentheses in order to make the input string valid. Return all possible results.Note: The input string may co...
复制链接

扫一扫