力扣22. 括号生成

22. 括号生成

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

示例：

输入：n = 3
输出：[
       "((()))",
       "(()())",
       "(())()",
       "()(())",
       "()()()"
     ]

思路：dfs 回溯

1. 产生有效解的情况是left和right均等于n

2. 如果left < right, 说明当前字符串中右括号数多于左括号数，这是不不符合要求的，可以提前终止

3. 如果left < n, 说明还有剩余的左括号没用完，可以继续递归左括号

4. 如果right < n, 说明还有剩余的右括号没用完，还可以继续递归右括号

做加法：

class Solution {
    public List<String> generateParenthesis(int n) {
        // dfs回溯
        List<String> res = new ArrayList<String>();
        if(n == 0)
            return res;
       dfs(res, 0, 0,n, "");
       return res;
    }

    public void dfs(List<String> res, int left, int right, int n, String curStr){
        // 如果left和right都等于n了，说明已经生产了一个解
        if(left == n && right == n){
            res.add(curStr);
            return;
        }
        // 剪枝，如果left < right, 说明当前字符串中右括号数多于左括号数，这是不不符合要求的，可以提前终止
        if(left < right){
            return;
        }

        // 如果左括号数小于n说明还可以继续递归左括号
        if(left < n){
            dfs(res, left + 1, right, n, curStr + "(");
        }

        // 如果右括号小于n，说明还可以继续递归右括号
        if(right < n){
            dfs(res, left, right + 1, n, curStr + ")");
        }
    }
}    

复杂度分析

上面的程序是对left 和 right 做加法，这里写个做减法的程序：

class Solution {
    public List<String> generateParenthesis(int n) {
        // dfs回溯

        List<String> res = new ArrayList<String>();
        if(n == 0)
            return res;
       dfs(res, n, n,n, "");
       return res;
    }

    public void dfs(List<String> res, int left, int right, int n, String curStr){
        // 如果left和right都等于n了，说明已经生产了一个解
        if(left == 0 && right == 0){
            res.add(curStr);
            return;
        }
        // 剪枝，如果left > right, 说明当前字符串中右括号数多于左括号数，这是不不符合要求的，可以提前终止
        if(left > right){
            return;
        }

        // 如果左括号数大于0，说明还可以继续递归左括号
        if(left > 0){
            dfs(res, left - 1, right, n, curStr + "(");
        }

        // 如果右括号大于0，说明还可以继续递归右括号
        if(right > 0){
            dfs(res, left, right - 1, n, curStr + ")");
        }
    }
}

使用标准的回溯，

上面两个程序其实是利用了String的不可变性，每个对 curStr 加上左右括号后其实对当前层次的curStr是没有影响的，相当于curStr自动回溯了，这里用StringBuilder代替String,标准的写一遍回溯，加深回溯的印象

class Solution {
    public List<String> generateParenthesis(int n) {
        // dfs回溯

        List<String> res = new ArrayList<String>();
        if(n == 0)
            return res;
        StringBuilder curStr = new StringBuilder();
       dfs(res, n, n,n, curStr);
       return res;
    }

    public void dfs(List<String> res, int left, int right, int n, StringBuilder curStr){
        // 如果left和right都等于n了，说明已经生产了一个解
        if(left == 0 && right == 0){
            res.add(curStr.toString());
            return;
        }
        // 剪枝，如果left > right, 说明当前字符串中右括号数多于左括号数，这是不不符合要求的，可以提前终止
        if(left > right){
            return;
        }

        // 如果左括号数大于0，说明还可以继续递归左括号
        if(left > 0){
            curStr.append("(");
            dfs(res, left - 1, right, n, curStr);
            curStr.deleteCharAt(curStr.length() - 1); // 回溯到添加前的转态
        }

        // 如果右括号大于0，说明还可以继续递归右括号
        if(right > 0){
            curStr.append(")");
            dfs(res, left, right - 1, n, curStr);
            curStr.deleteCharAt(curStr.length() - 1);       // 回溯到添加前的转态
        }
    }
}

思路来源：

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