LeetCode（5） 括号生成

给出 n 代表生成括号的对数，请你写出一个函数，使其能够生成所有可能的并且有效的括号组合。

例如，给出 n = 3，生成结果为：

[
“((()))”,
“(()())”,
“(())()”,
“()(())”,
“()()()”
]

• 一，官方解答

 public static List<String> generateParenthesis(int n) {
                    List<String> list = new ArrayList<>();
                    generate("", list, 0, 0, n);

                    return list;
            }

            //count1统计“(”的个数，count2统计“)”的个数
            public static void generate(String sublist , List<String> list , int left, int right, int n){

                    if(left > n || right > n) return;      //左括号和括号最大不能大于n

                    if(left == n && right == n)  list.add(sublist);      //刚好都等于n，则添加到list集合中


                    if(left >= right){
                        String ans1 = new String(sublist);
                        generate(sublist+"(", list, left+1, right, n);         //递归
                        generate( ans1+")", list, left, right+1, n);          //递归
                     }
             }

思路：
只有在我们知道序列仍然保持有效时才添加 ‘(’ or ‘)’，而不是像暴力法那样每次都添加。我们可以通过跟踪到目前为止放置的左括号和右括号的数目来做到这一点，如果我们还剩一个位置，我们可以开始放一个左括号。 如果它不超过左括号的数量，我们可以放一个右括号。
官方解答用的是回溯法，都走一遍，不行就退回之前的位置，走其他的方案。

• 二，改变判定条件

public static List<String> generateParenthesis(int n) {
                        List<String> list = new ArrayList();
                        generate("", list, 0, 0, n);
                        return list;
                }

                public static void generate(String sublist,List<String> list, int left, int right, int max){
                        if (sublist.length() == max * 2) {       //做判断
                            list.add(sublist);
                            return;
                        }

                        if (left < max)                 //左括号小于max，添加"("
                            generate(sublist+"(", list, left+1, right, max);
                        if (right < left)                //右括号小于左括号，添加")"
                            generate(sublist+")", list,  left, right+1, max);
                }

思路：
方法二和方法一差不多，是我自己的思路。也是递归和回溯法的思路。

• 三，利用DFS深度优先

 public static List<String> generateParenthesis(int n) {
                List<String> list = new ArrayList<>();
                generate("", list, n, n);
                return list;
        }

        public static void generate(String sublist, List<String> list, int left, int right){
                if(left > right){                 //左括号数要大于右括号数
                    return;
                }

                if(left > 0){                    //左括号数没有减到0，则递归
                    generate( sublist + "(" , list, left-1, right);         //递归
                }

                if(right > 0){                 //右括号数没有减到0，则递归
                    generate( sublist + ")" , list, left, right-1);        //递归
                }

                if(left == 0 && right == 0){           //左右括号刚刚好，字符串添加到list集合中
                list.add(sublist);
                return;                                        //回溯
            }
      }

思路：
深度优先算法，虽然DFS不一定能找出最优解，而且利用的条件也非常苛刻，但是DFS无疑是最好理解的一种方法，它能穷举完所有的情况，筛选出符合条件的。