从简单到困难--三道括号相关算法题

声明：本博客记录的题目全部来自于力扣，对这些题目进行整理的人为花花酱以及他的个人网站，本博客主要用来记录自己的算法学习的笔记。

20.有效的括号

题目描述请点击大标题

解题思路

解题思路是非常简单的，就是当一个括号是左括号(的时候就入栈，如果是右括号)就将栈栈顶取出，如果是对应的左括号则是正常的括号。有助于理解我们将举两个例子
例子一：

例子二：

所以在这个题目中我们需要的数据结构是栈和一个可以匹配括号的方法，这里我们使用map这个数据结构。

代码编写

class Solution {
    public boolean isValid(String s) {
        int len = s.length();
        //括号都是成双的，如果不是二的倍数，那就是不合法
        if(len % 2 != 0){
            return false;
        }
        Stack<Character> stack = new Stack<>();
        //因为当我们遇到右括号的时候才需要判断，所以我们将右括号设置成key值
        Map<Character, Character> map = new HashMap<>(){{
            put(')','(');
            put(']','[');
            put('}','{');
        }};

        for(int i = 0; i < len; i++){
            char bracket = s.charAt(i);
            if(map.containsKey(bracket)){
                if(stack.isEmpty() || stack.peek() != map.get(bracket)){
                    return false;
                }
                stack.pop();
            }else{
                stack.push(bracket);
            }
        }

        return stack.isEmpty();
    }
}

22.括号生成

题目描述请点击大标题

解题思路

这首先有一个很暴力的方法，那就是枚举所有的可能，然后通过上一个代码来判断是不是有效的括号，然后返回。

但是我们还有一种其他的方法，那就是确保我们走的路都是正确的，不过在这之前我们先看看n=2枚举的树：

从上面的图我们可以看到很多地方都是要一开始就是错的，可以直接剪枝，现在我们把这个树剪一下，剪的时候也发现了规律，剪完如下图：

规律是：

• 题目给我们n,所以左右括号都只有n个，当所以哪个括号超过n的枝条直接剪掉
• 在左括号都是大于等于右括号的，如果右括号的数量比左括号多，那就不合法
  所以我们要有两个变量int eft = n, right = n;
  结束的条件是ledt = right = 0在满足上面的条件以后，满足这个就是一个合法的括号组合

代码编写

class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> combain = new ArrayList<String>();
        DFS("",n,n,combain);
        return combain;
    }

    public void DFS(String brackets,int left,int right,List<String> combain){
        if(left == 0 && right == 0){
            combain.add(brackets);
            return;
        }

        if(left > right){
            return;
        }

        if(left > 0){
            DFS(brackets+"(", left - 1, right, combain);
        }
        if(right > 0){
            DFS(brackets+")", left, right - 1, combain);
        }
    }
}

301.删除无效的括号

题目描述请点击大标题

解题思路

• 删除无效括号，很明显是有多余的括号使得括号对不匹配，而且不是左括号多了，就是右括号多了，因此我们需要计算什么括号多了，多了多少个，这样就可以删减最小的括号数，使得括号有效

/**
 *如果遇到左括号，则lremove加一
 *如果遇到右括号，lremove>0则lremove减一，否则rremove加一
 */
int lremove = 0, rremove = 0; 
        for(int i = 0; i < s.length(); i++){
            char ch = s.charAt(i);
            if(ch == '('){
                lremove++;
            }else if(ch ==')'){
                if(lremove == 0){
                    rremove++;
                }else{
                    lremove--;
                }
            }
        }

• 接着就是减括号了，这里我们使用递归来解：
  1.当lremove == 0和rremove == 0的时候说明要减的括号减完了，这个时候判断一下这个括号是否有效，如果有效就添加再返回，无效直接返回。
  2.然后用循环删减括号，如果前一个括号和后一个括号完全相同则不删减，如果要删减的括号数已经大于已经存在的括号数，则直接返回。然后继续删减左括号或者右括号

    public void delete(int lremove, int rremove, String s,int index){
        //需要删除的括号已经删除完毕
        if(lremove == 0 && rremove == 0){
            if(isValid(s)){
                ans.add(s);
            }
            return;
        }

        for(int i = index;i < s.length(); i++){
            //如果前一个括号和后一个括号相同，则不做删除
            if(i != index && s.charAt(i) == s.charAt(i - 1)){
                continue;
            }
            //当还需要删除的括号数大于字符串长度，说明已经不够删了，直接返回
            if(lremove + rremove > s.length() - i){
                return;
            }
            //删除左括号
            if(lremove > 0 && s.charAt(i) == '('){
                delete(lremove - 1, rremove, s.substring(0,i) + s.substring(i+1), i);
            }
            //删除右括号
            if(rremove > 0 && s.charAt(i) == ')'){
                delete(lremove, rremove - 1, s.substring(0,i) + s.substring(i+1), i);
            }
        }
    }

• 有效括号判断就是看是不是严格的左括号大于等于右括号， 其实和第一题是一样的，但是第一题有很多类型的括号，所以要用到map和栈，这里我们直接可以使用计数来代替

    public boolean isValid(String s){
        int count = 0;
        for(int i = 0; i < s.length(); i++){
            if(s.charAt(i) == '('){
                count++;
            }else if(s.charAt(i) == ')'){
                count--;
                if(count < 0){
                    return false;
                }
            }
        }
        return count == 0;
    }

代码编写

完整代码如下

class Solution {
    List<String> ans = new ArrayList<String>();
    public List<String> removeInvalidParentheses(String s) {
        int lremove = 0, rremove = 0; 
        for(int i = 0; i < s.length(); i++){
            char ch = s.charAt(i);
            if(ch == '('){
                lremove++;
            }else if(ch ==')'){
                if(lremove == 0){
                    rremove++;
                }else{
                    lremove--;
                }
            }
        }

        delete(lremove,rremove,s,0);

        return ans;
    }

    public void delete(int lremove, int rremove, String s,int index){
        //需要删除的括号已经删除完毕
        if(lremove == 0 && rremove == 0){
            if(isValid(s)){
                ans.add(s);
            }
            return;
        }

        for(int i = index;i < s.length(); i++){
            //如果前一个括号和后一个括号相同，则不做删除
            if(i != index && s.charAt(i) == s.charAt(i - 1)){
                continue;
            }
            //当还需要删除的括号数大于字符串长度，说明已经不够删了，直接返回
            if(lremove + rremove > s.length() - i){
                return;
            }
            //删除左括号
            if(lremove > 0 && s.charAt(i) == '('){
                delete(lremove - 1, rremove, s.substring(0,i) + s.substring(i+1), i);
            }
            //删除右括号
            if(rremove > 0 && s.charAt(i) == ')'){
                delete(lremove, rremove - 1, s.substring(0,i) + s.substring(i+1), i);
            }
        }
    }


    public boolean isValid(String s){
        int count = 0;
        for(int i = 0; i < s.length(); i++){
            if(s.charAt(i) == '('){
                count++;
            }else if(s.charAt(i) == ')'){
                count--;
                if(count < 0){
                    return false;
                }
            }
        }
        return count == 0;
    }
}