leetcode ：[22. 括号生成](https://leetcode-cn.com/problems/generate-parentheses/)

# leetcode ：[22. 括号生成](https://leetcode-cn.com/problems/generate-parentheses/)

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

**示例 1：**

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

**示例 2：**

```
输入：n = 1
输出：["()"]
```

**提示：**

- `1 <= n <= 8`

Related Topics

字符串

动态规划

回溯

## 思路1：暴力法

递归生成所有的可能性，然后判断出合法的括号格式。参考leetcode32判断有效括号。

每一位都可能是左括号和右括号。所以递归进行回溯，遍历每一种可能性。

```java
class Solution {
    private List<String> lists = new ArrayList<>();
    public List<String> generateParenthesis(int n) {
        generateAll(new char[n*2],0);
        return lists;
    }
    public void generateAll(char[] strs,int pos){
        if(pos == strs.length){ //长度为2n
            if(valid(strs)){
                lists.add(new String(strs));
            }
        }else{
            strs[pos] = '(';
            generateAll(strs,pos+1);
            strs[pos] = ')';
            generateAll(strs,pos+1);
        }
    }
    public boolean valid(char[] strs){
        int balance = 0;
        for(int i = 0 ; i < strs.length;i++){
            if(strs[i]=='('){
                balance++;
            }else{
                balance--;
            }
            if(balance < 0){
                return false;
            }
        }
        return balance==0;
    }
}
    解答成功:
            执行耗时:2 ms,击败了24.68% 的Java用户
            内存消耗:41.4 MB,击败了16.85% 的Java用户
```

## ## 思路2：递归+回溯法

上述暴力解法，是把每一种可能性计算出来，再看合法不合法。那么我们可以在递归的过程中，如果已经不合法了，那就不需要递归下去了。

通过左括号数量小于n，我们可以放置左括号。如果右括号数量小于左括号，我们可以放置右括号。

```java
class Solution {
    private List<String> lists = new ArrayList<>();
    public List<String> generateParenthesis(int n) {
        generateAll(new StringBuilder(),0,0,n);
        return lists;
    }
    public void generateAll(StringBuilder sb,int leftNum,int rightNum,int n){
        //达到2n长度
        if(sb.length() == 2*n){
            lists.add(sb.toString());
            return;
        }
        //如果左括号数量小于 左括号总数
        if(leftNum < n){
            sb.append("(");
            generateAll(sb,leftNum+1,rightNum,n);
            sb.deleteCharAt(sb.length()-1);
        }
        if(rightNum < leftNum){
            sb.append(")");
            generateAll(sb,leftNum,rightNum+1,n);
            sb.deleteCharAt(sb.length()-1);
        }
    }
}
解答成功:
            执行耗时:1 ms,击败了75.11% 的Java用户
            内存消耗:41.2 MB,击败了26.74% 的Java用户
```

##  思路3： 递归+回溯

```java
class Solution {
    private List<String> lists = new ArrayList<>();
    public List<String> generateParenthesis(int n) {
        generateAll(new StringBuilder(),n,n);
        return lists;
    }
    public void generateAll(StringBuilder sb,int leftNum,int rightNum){
        if(leftNum == 0 && rightNum==0){
            lists.add(sb.toString());
            return;
        }
        //剩余的左括号等于右括号 只能添加左括号
        if(leftNum == rightNum){
            sb.append("(");
            generateAll(sb,leftNum-1,rightNum);
            sb.deleteCharAt(sb.length()-1);
        }else if(leftNum < rightNum){//剩余左括号数量小于右括号  左右括号都可以添加 都必须要leftNum > 0
            sb.append(")");
            generateAll(sb,leftNum,rightNum-1);
            sb.deleteCharAt(sb.length()-1);
            if(leftNum > 0){
                sb.append("(");
                generateAll(sb,leftNum-1,rightNum);
                sb.deleteCharAt(sb.length()-1);
            }
        }
    }
}
    解答成功:
            执行耗时:0 ms,击败了100.00% 的Java用户
            内存消耗:41.3 MB,击败了21.30% 的Java用户
```