22_括号生成

22_括号生成

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

有效括号组合需满足：左括号必须以正确的顺序闭合。

示例 1：

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

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

左右括号要对应，不能哪个多哪个少

这题有许多不同的解法
放上几个我觉得不错的解法，这些解法基本上都是递归的形式：
解法一：

class Solution(object):
    def generateParenthesis(self, n):
        """
        :type n: int
        :rtype: List[str]
        """
        ans = []   # 初始化一个空列表用来储存结果

        def resc(s,left,right):
            if len(s) == 2 * n:   # 递归的终止条件
                ans.append("".join(s))   # join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
                return 
            
            if left < n:
                s.append('(')
                resc(s,left + 1,right)
                s.pop()
            
            if right <  left:
                s.append(')')
                resc(s,left,right + 1)
                s.pop()
        
        resc([],0,0)
        return ans

解法二（深度优先遍历）：

class Solution(object):
    def generateParenthesis(self, n):
        """
        :type n: int
        :rtype: List[str]
        """
        res = []
        cur_str = ''
        def dfs(cur_str,left,right):
            if left == 0 and right == 0:   # 递归终止条件
                res.append(cur_str)
                return 
            if left > right:   # 保证左右括号对应
                return
            if left > 0:
                dfs(cur_str + '(',left - 1,right)
            if right > 0:
                dfs(cur_str + ')',left,right - 1)
        dfs(cur_str,n,n)
        return res

解法三：与解法二相比解法三多传一个参数，left-1，变成了left+1 ，仍然是深度优先搜索

class Solution(object):
    def generateParenthesis(self, n):
        """
        :type n: int
        :rtype: List[str]
        """
        res = []
        cur_str = ''
        def dfs(cur_str,left,right,n):
            if left == n and right == n:
                res.append(cur_str)
                return   
            if left < right:
                return
            if left < n:
                dfs(cur_str + '(',left + 1,right,n)
            if right < n:
                dfs(cur_str + ')',left,right + 1,n)
        dfs(cur_str,0,0,n)
        return res

解法四：栈的形式

class Solution(object):
    def generateParenthesis(self, n):
        """
        :type n: int
        :rtype: List[str]
        """
        if n == 0:
            return []
        stack = [('(', 1, 0)]  # 初始化一个栈
        ans = []
        while stack:
            cur_ans, n_left, n_right = stack.pop()    # 初始化各个参数
            if len(cur_ans) == 2 * n:
                ans.append(cur_ans)
                # continue
            if n_left < n:
                stack.append((cur_ans + '(', n_left + 1, n_right))
            if n_right < n_left:
                stack.append((cur_ans + ')', n_left, n_right + 1))
        return ans

这四种解法相比，解法四的运行时间要略快一些