【力扣日記】022 括號生成 | 收藏| 遞歸|回溯算法

題目描述

給出 n 代表生成括號的對數，請你寫出一個函數，使其能夠生成所有可能的並且有效的括號組合。

例如，給出 n = 3，生成結果爲：
[ “((()))”,
“(()())”,
“(())()”,
“()(())”,
“()()()”]

算法思路

遞歸

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        if n == 0:
            return [""]
        elif n == 1:
            return ["()"]
        elif n == 2:
            return ["()()", "(())"]
        result = []
        for i in range(n):
            j = n - 1 - i
            temp1 = self.generateParenthesis(i)
            temp2 = self.generateParenthesis(j)
            result.extend(["(%s)%s" % (p, q) for p in temp1 for q in temp2])
        return result

深度優先搜索+剪枝

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        if n==0:return ['']
        if n==1:return ['()']
        self.res=[]
        self.helper(n,n)
        return self.res

    def helper(self,l,r,tp=''):
        '''
        l:左括號數
        r:右括號數
        tp:臨時保存當前括號組合
        '''
        # 當左括號數量多於右括號時，表示當前tp不是合法括號，回溯。
        if l>r:return
        if l==0 and r==0:
            self.res.append(tp)
            return
        if l:self.helper(l-1,r,tp+'(')
        if r:self.helper(l,r-1,tp+')')

執行用時 :44 ms, 在所有 Python3 提交中擊敗了48.48%的用戶
內存消耗 :13.8 MB, 在所有 Python3 提交中擊敗了5.03%的用戶

其他參考

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        result = "()"*n
        p = Solution.permutation
        result = p(self, result)
        r = []
        for i in result:
            if Solution.validParentheses(self, i):
                r.append(i)
        return r


    def validParentheses(self, s:str):
        if not s:
            return True
        left_p = []
        dict_p = {")": "("}
        for i in s:
            if i == "(":
                left_p.append(i)
            if i == ")":
                if not left_p:
                    return False
                if dict_p[i] == left_p[-1]:
                    left_p.pop()
                else:
                    return False
        return left_p == []

    def permutation(self, s: str):  # 超時,可能是因爲全排列重複的太多了.手動寫個全排列就穩了.
        if len(s) == 1:
            return s
        count = 1
        result = [s[0]]
        while count < len(s):
            temp = []
            for i in result:
                for j in range(len(result[0]) + 1):
                    temp.append(i[:j] + s[count] + i[j:])
            temp = list(set(temp))
            result = temp[:]
            count += 1
        return result

執行用時 :152 ms, 在所有 Python3 提交中擊敗了5.30%的用戶
內存消耗 :26 MB, 在所有 Python3 提交中擊敗了5.19%的用戶