LeetCode_22_中等_括号生成


1. 题目

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

示例 1:

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

示例 2:

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


提示

  • 1 ≤ n ≤ 8 1 \leq n \leq 8 1n8

2. 思路及代码实现(Python)

2.1 暴力法

该思路先生成所有的 2 2 n 2^{2n} 22n 个 “(” 和 “)” 字符串构成的序列,然后检查生成的序列是否有效,一共有 n n n 对括号,共 2 n 2n 2n 个字符,每个位置存在两种不同的选择,因此总共有 2 2 n 2^{2n} 22n 种序列。

为了生成所有序列,可以使用递归。长度为 n n n 的序列就是在长度为 n − 1 n−1 n1 的序列后加一个 “(” 或 “)”。为了检查序列是否有效,我们遍历这个序列,并使用一个变量 b a l bal bal 表示左括号的数量减去右括号的数量。如果在遍历过程中 b a l bal bal 的值小于零,或者结束时 b a l bal bal 的值不为零,那么该序列就是无效的,否则它是有效的。前者说明,遍历一段字符串时出现 “)” 大于 “(” 的数量,显然说明该子串不能成对;而后者说明整个字符串的左右括号数并不相等。

该算法的时间复杂度为: O ( 2 2 n n ) O(2^{2n}n) O(22nn),对于 2 2 n 2^{2n} 22n 个序列中的每一个,对其进行有效性的验证的复杂度为 O ( n ) O(n) O(n)。而空间复杂度除了存储答案组之外,还需要存储探索答案的栈深,复杂度为 O ( n ) O(n) O(n)

class Solution:
    def generateParenthesis(self, n: int):
        def generate(A):
            if len(A) == 2*n:
                if valid(A):
                    ans.append("".join(A))
            else:
                A.append('(')
                generate(A)
                A.pop()
                A.append(')')
                generate(A)
                A.pop()

        def valid(A):
            bal = 0
            for c in A:
                if c == '(': bal += 1
                else: bal -= 1
                if bal < 0: return False
            return bal == 0

        ans = []
        generate([])
        return ans

执行用时:71 ms
消耗内存:16.54 MB

2.2 回溯法

上述方法是遍历生成所有的可能的序列,然后再进行判断,这里我们发现有可以改进的地方,就是在生成序列时,提前跟踪序列的左右括号的数据,来决定扩展序列时所选择的括号。例如,已有子序列的左括号数量不大于 n n n,则可以放置左括号,如果右括号数量小于左括号数量,可以放置一个右括号。

该算法的复杂度分析依赖于该有效序列可以回溯出 的元素个数。这证明是第 n n n 个卡特兰数 1 n + 1 ( 2 n n ) \dfrac{1}{n+1}\dbinom{2n}{n} n+11(n2n) ,这是由 4 n n n \dfrac{4^n}{n\sqrt{n}} nn 4n 渐近界定的。因此时间复杂度为 O ( 4 n n ) O(\dfrac{4^n}{\sqrt{n}}) O(n 4n)。空间复杂度为保存答案和保存栈深的消耗,为 O ( n ) O(n) O(n)

class Solution:
    def generateParenthesis(self, n: int):
        ans = []
        def backtrack(S, left, right):
            if len(S) == 2 * n:
                ans.append(''.join(S))
                return
            if left < n:
                S.append('(')
                backtrack(S, left+1, right)
                S.pop()
            if right < left:
                S.append(')')
                backtrack(S, left, right+1)
                S.pop()

        backtrack([], 0, 0)
        return ans

执行用时:42 ms
消耗内存:16.55 MB


题解来源:力扣官方题解

  • 23
    点赞
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值