22括号生成-hot100-java-回溯

一、问题描述：

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
示例 1：    输入：n = 3    输出：["((()))","(()())","(())()","()(())","()()()"]
示例 2：   输入：n = 1    输出：["()"]
提示：     1 <= n <= 8

二、题解：

思路1：

首先,先模拟一下吧：

先看看n = 1:
()
10
n = 2：
()(),(())
1010 1100
n=3:
()()() ((())) (())() (()()) ()(())
101010 111000 110010 110101 101100

通过这个模拟，就可以知道01比特位可以一一对应)和(符号，这个叫做括号串的二进制映射，于是想到了位图思想、位运算、回溯、穷枚举。

于是可以这样写：首先使用set集合获取所有二进制映射，然后再遍历set，将所有的二进制转为括号串。为什么用二进制映射？因为01比特串占用空间小，节约内存，位图思想可以减少oom。也许这个题用位图思想有点像杀鸡用牛刀了。为什么用set来保存映射？set可以过滤掉重复的比特串，从而过滤掉重复的括号串，因为也不知道会不会添加到重复的比特串。毕竟使用的是第一眼想到的思路，尽可能稳妥得快速写出来。

题解1：

class Solution {
    public List<String> generateParenthesis(int n) {
        Set<Integer> set = new HashSet<>();
        getFlag(n, n, set, 0);
        List<String> list = new ArrayList<>();

        StringBuilder builder = new StringBuilder();
        for (int i :set) {

            while (i != 0){
                int j = i & 1;
                if (j == 1){
                    builder.append(')');
                }else {
                    builder.append('(');
                }
                i >>>= 1;
            }
            list.add(builder.toString());
            builder = new StringBuilder();
        }

        return list;
    }

    private void getFlag(int nLeft, int nRight, Set<Integer> set, int myRes) {
        if (nLeft > nRight) return;
        if (nLeft == 0 || nRight == 0) {
            set.add(myRes << nRight);
            return;
        }
        getFlag(nLeft - 1, nRight, set, (myRes << 1 )| 1);
        getFlag(nLeft, nRight - 1, set, myRes << 1);
    }
}

测试：

@Test
public void testSolution(){
    int[] arr = {
            1,
            3,
    };
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i] + " is " + generateParenthesis(arr[i]));
    }
}

模拟acm模式：

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    String s = scanner.nextLine();
    int n = Integer.parseInt(s);
    Solution solution = new Solution();
    System.out.println(solution.generateParenthesis(n));
}

不过应该是没有重复的。于是可以优化一下：

优化2：

class Solution {
    List<String> list;
    public List<String> generateParenthesis(int n) {
        list = new ArrayList<>();
        getFlag(n, n, 0);
        return list;
    }

    private void getFlag(int nLeft, int nRight, int myRes) {
        if (nLeft > nRight) return;
        if (nLeft == 0 || nRight == 0) {
            addToList(myRes << nRight);
            return;
        }
        getFlag(nLeft - 1, nRight,  (myRes << 1 )| 1);
        getFlag(nLeft, nRight - 1,  myRes << 1);
    }

    private void addToList(int i) {
        StringBuilder builder = new StringBuilder();
            while (i != 0){
                int j = i & 1;
                if (j == 1){
                    builder.append(')');
                }else {
                    builder.append('(');
                }
                i >>>= 1;
            }
            list.add(builder.toString());
    }

}

再来优化一下时间复杂度，空间换时间：

优化3：

class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> list = new ArrayList<>();
        getFlag(n, n,list, 0);
        return list;
    }

    private void getFlag(int nLeft, int nRight,List<String> list, int myRes) {
        if (nLeft > nRight) return;
        if (nLeft == 0 || nRight == 0) {
            int i = myRes << nRight;
            StringBuilder builder = new StringBuilder();
            while (i != 0){
                int j = i & 1;
                if (j == 1){
                    builder.append(')');
                }else {
                    builder.append('(');
                }
                i >>>= 1;
            }
            list.add(builder.toString());
            return;
        }
        getFlag(nLeft - 1, nRight,list,  (myRes << 1 )| 1);
        getFlag(nLeft, nRight - 1,list,  myRes << 1);
    }
}

这个是回溯实锤了