leetcode 22. 括号生成

题目描述

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
有效括号组合需满足：左括号必须以正确的顺序闭合。

示例 1：

输入：n = 3

输出：["((()))","(()())","(())()","()(())","()()()"]

示例 2：

输入：n = 1

输出：["()"]

提示：

1 <= n <= 8

解题思路
要生成有效的括号组合，
首先，要把2*n个左右括号都用完
然后，每在字符串后面添加一个括号的时候，其前面的右括号数不能多于左括号，不然有右括号无法被匹配，这种情况直接剪枝
当左右括号都用完，就把当前字符串加到结果集合里面

我们用left和right计数当前左括号和右括号的剩余数

class Solution {
    List<String>result=new ArrayList();
    public List<String> generateParenthesis(int n) {
        generate("",n,n);
        return result;
    }
    public void generate(String s,int left,int right){
        if(left==0&&right==0){
            result.add(s);
            return ;
        }
        if(left>right)//左括号剩下的比右括号剩下的多，说明前面肯定有右括号不能匹配，直接剪枝
           return ;
        if(left>0)//还剩下有左括号,加一个左括号
          generate( s+"(", left-1,right);
        if(right>0)//还剩下有右括号，加一个右括号
          generate( s+")", left,right-1);
    }
}

从结果的生成顺序我们可以看出来，整个程序的过程是先把左括号用完，再用右括号，然后回溯先用右括号，再用左括号

需要注意的是，我们在递归函数中使用的是s+"("这种形式拼接字符串，每一次都会创建新的对象，即子函数中的字符串s跟调用函数中的字符串s是不一样的，比如第一层递归，在第一个generate函数结束返回的时候，s仍然是空串，不会被子函数改变，所以它可以继续拼接右括号

思路2：计数当前字符串中的左括号和右括号的数量，如果其中一个大于了n或者右括号的数量已经多于了左括号，直接剪枝

class Solution {
    List<String> res = new ArrayList();
  
    public List<String> generateParenthesis(int n) {
    //计数左右括号当前的个数
      generate( "",0,0,n);
      return res;
    }
    public void generate(String s,int left,int right,int n){
        if(left==n&&right==n){
            res.add(s);
        }
        if(right>left||right>n||left>n){//使用数量超过了n,或者右括号数量大于左括号数量，不是合法的匹配
           return;
        }
        generate(s+"(", left+1,right, n);
        generate(s+")", left,right+1, n);
    }   
}

这个代码也可，不同的是StringBuilder在拼接的时候，整个内存中只有一个StringBuilder，不会创建新的对象，而上面的方法，每拼接一次，都会创建新的String对象，这应该也是下面这个解法时间更短的原因所在

class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> res = new ArrayList();

        if (n == 0) {
            return res;
        }

        /// 走过的路径
        StringBuilder track = new StringBuilder();
        backtrack(n, n, track, res);
        return res;
    }

    /// 可用left个左括号,right个右括号
    void backtrack(int left, int right, StringBuilder track, List<String> res) {
        if (left == 0 && right == 0) {
            res.add(track.toString());
            return;
        }
        if (left < 0 || right < 0) {
            return;
        }
        if (right < left) {
            return;
        }

        // left
        track.append('(');
        backtrack(left - 1, right, track, res);
        track.deleteCharAt(track.length() - 1);

        // right
        track.append(')');
        backtrack(left, right - 1, track, res);
        track.deleteCharAt(track.length() - 1);
    }
}

官方暴力递归

直接在原来的数组中操作，没有拼接，也没有创建对象

class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> combinations = new ArrayList<String>();
        generateAll(new char[2 * n], 0, combinations);
        return combinations;
    }

    public void generateAll(char[] current, int pos, List<String> result) {
        if (pos == current.length) {
            if (valid(current)) {
                result.add(new String(current));
            }
        } else {
            current[pos] = '(';
            generateAll(current, pos + 1, result);
            current[pos] = ')';
            generateAll(current, pos + 1, result);
        }
    }

    public boolean valid(char[] current) {
        int balance = 0;
        for (char c: current) {
            if (c == '(') {
                ++balance;
            } else {
                --balance;
            }
            if (balance < 0) {
                return false;
            }
        }
        return balance == 0;
    }
}


作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/generate-parentheses/solution/gua-hao-sheng-cheng-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

改成广度优先搜索感觉人间清醒

参考：https://leetcode-cn.com/problems/generate-parentheses/solution/hui-su-suan-fa-by-liweiwei1419/

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class Solution {

    class Node {
        /**
         * 当前得到的字符串
         */
        private String res;
        /**
         * 剩余左括号数量
         */
        private int left;
        /**
         * 剩余右括号数量
         */
        private int right;

        public Node(String str, int left, int right) {
            this.res = str;
            this.left = left;
            this.right = right;
        }
    }

    public List<String> generateParenthesis(int n) {
        List<String> res = new ArrayList<>();
        if (n == 0) {
            return res;
        }
        Queue<Node> queue = new LinkedList<>();
        queue.offer(new Node("", n, n));

        while (!queue.isEmpty()) {

            Node curNode = queue.poll();
            if (curNode.left == 0 && curNode.right == 0) {
                res.add(curNode.res);
            }
            if (curNode.left > 0) {
                queue.offer(new Node(curNode.res + "(", curNode.left - 1, curNode.right));
            }
            if (curNode.right > 0 && curNode.left < curNode.right) {
                queue.offer(new Node(curNode.res + ")", curNode.left, curNode.right - 1));
            }
        }
        return res;
    }
}