22.括号生成

22.括号生成

1.题目

2.我的解决方案

这道题，我真的不会，，，，真的，越刷题，打击越大

3.官方的解决方案

暴力法（回溯法，没有剪枝）

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        # 暴力法
        def generate(bracket):
            if len(bracket) == 2*n:
                if valid(bracket):  # 在结构形成的时候判断是否有效
                    res.append("".join(bracket))    # 存储答案，答案要符合格式要求
            else: 
                # 使用递归产生括号
                bracket.append('(')
                generate(bracket)
                bracket.pop()
                bracket.append(')')
                generate(bracket)
                bracket.pop()

        # 判断是否有效
        def valid(bracket):
            bal = 0
            for ch in bracket:  # 使用in关键字，不需要使用pop
                if ch == '(':
                    bal += 1
                else:
                    bal -= 1
                if bal < 0:
                    return False
            return bal == 0	# 返回的是布尔值
       
        res = []
        bracket = []
        generate(bracket)
        return res

• 时间复杂度:$O(n\ast 2^{2n})$ :控制台给出的数字是n，二叉树生成$2^{2n}$个叶子结点，判断每个结点是否有效需要时间复杂度$O(n)$
• 空间复杂度:$O(n)$ ：除了返回的数组之外，每一层递归需要的空间复杂度为$O(1)$,最多递归$2\ast n$层

回溯法（剪枝函数）

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        def generate(bracket, left, right):
            if len(bracket) == 2*n: # 这里接收到的直接是有效的
                res.append("".join(bracket))
            if left < n:    # 剪枝函数
                # 使用递归产生括号
                bracket.append('(')
                generate(bracket, left+1, right)
                bracket.pop()
            if right < left:    # 剪枝函数
                bracket.append(')')
                generate(bracket, left, right+1)
                bracket.pop()

        res = []
        generate([], 0, 0)
        return res   

通式法

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        # 总结该问题的通用形式(a)b
        # 题目要求形成n个括号对，上面的通式中，有一个括号对
        # a和b都可以表示若干括号对，且a和b可以是空的，但是必须保证能形成足够数量的括号对
        # a如果是一个括号对，b必须是n-1-1个括号对
        # a如果是i个括号对，b必须是n-1-i个括号对
        # 可见b形成的括号对是受a限制的
        if n == 0:
            return [""]
        res = []
        for i in range(n):  
            for left in self.generateParenthesis(i): # a可以形成的括号对数(还是使用递归产生)
                for right in self.generateParenthesis(n-i-1): # b可以形成的括号对数
                    res.append("({}){}".format(left, right))

        return res