生成括号问题中超出了Python递归深度_Python_Python 3.x

生成括号问题中超出了Python递归深度

python python-3.x

生成括号问题中超出了Python递归深度,python,python-3.x,Python,Python 3.x,我用蛮力解决如下问题 class Solution: def generateParenthesis(self, n: int) -> List[str]: C, ans = [], [] ans = self.generate(C, n, ans) return ans def generate(self, C, n, ans): if len(C) == 2*n: if s

我用蛮力解决如下问题

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        C, ans = [], []
        ans = self.generate(C, n, ans)
        return ans
    
    def generate(self, C, n, ans):
        if len(C) == 2*n:
            if self.valid(C):
                ans.append(''.join(C))
        else:
            C.append('(')
            ans = self.generate(C, n, ans)
            C.pop()
            C.append(')')
            ans = self.generate(C, n, ans)
            C.pop()
        return ans
        
        
    def valid(self, C):
        bal = 0
        for c in C:
            if c == '(': bal+=1
            else: bal-=1
            if bal<0: return False
        return bal == 0

当我将第8行、第9行和第10行合并如下时，我不再得到错误

if len(C) == 2*n and self.valid(C):
    ans.append(''.join(C))

看起来有点奇怪。为什么会这样

任何帮助都将不胜感激。

在代码更改后，您的程序在逻辑上不再等同于以前的实现。看看else分支，你就会明白我的意思了。在原始版本中，如果出现以下情况，则执行else分支：

蓝（C）！=2*n

在修改版本中，如果：

蓝（C）！=2*n或非自有效（C）

但目前我不明白为什么这种变化可以解释观察到的行为，因为它甚至应该产生更多的调用来生成

顺便说一句，如果您考虑到（）的所有组合都是有效的，那么您不需要检查逻辑，前提是在迭代过程中应用了以下条件：

在generate调用的每个级别上，右括号和右括号的数量最多
在生成调用的每个级别上，最多有n个左括号

有了这些知识，您可以使用：

class Solution2:
    def generateParenthesis(self, n: int) -> List[str]:
        C, ans = [], []
        ans = self.generate(C, n, ans, 0, 0)
        return ans

    def generate(self, C, n, ans, op, cl):
        #print(n, op, cl)
        if op < n or cl < n:
            if op < n:
                ans = self.generate(C + ['('], n, ans, op+1, cl)
            if op > cl:
                ans = self.generate(C + [')'], n, ans, op,   cl+1)
        else:
            ans.append(''.join(C))
        return ans

类解决方案2：
def generateParenthesis（self，n:int）->List[str]：
C、 ans=[]，[]
ans=self.generate（C，n，ans，0，0）
返回ans
def生成（自身、C、n、ans、op、cl）：
#打印（n、op、cl）
如果opcl：
ans=self.generate（C+['）']，n，ans，op，cl+1）
其他：
ans.append（“”.join（C））
返回ans

代码更改后，您的程序在逻辑上不再等同于以前的实现。看看else分支，你就会明白我的意思了。在原始版本中，如果出现以下情况，则执行else分支：

蓝（C）！=2*n

在修改版本中，如果：

蓝（C）！=2*n或非自有效（C）

但目前我不明白为什么这种变化可以解释观察到的行为，因为它甚至应该产生更多的调用来生成

顺便说一句，如果您考虑到（）的所有组合都是有效的，那么您不需要检查逻辑，前提是在迭代过程中应用了以下条件：

在generate调用的每个级别上，右括号和右括号的数量最多
在生成调用的每个级别上，最多有n个左括号

有了这些知识，您可以使用：

class Solution2:
    def generateParenthesis(self, n: int) -> List[str]:
        C, ans = [], []
        ans = self.generate(C, n, ans, 0, 0)
        return ans

    def generate(self, C, n, ans, op, cl):
        #print(n, op, cl)
        if op < n or cl < n:
            if op < n:
                ans = self.generate(C + ['('], n, ans, op+1, cl)
            if op > cl:
                ans = self.generate(C + [')'], n, ans, op,   cl+1)
        else:
            ans.append(''.join(C))
        return ans

类解决方案2：
def generateParenthesis（self，n:int）->List[str]：
C、 ans=[]，[]
ans=self.generate（C，n，ans，0，0）
返回ans
def生成（自身、C、n、ans、op、cl）：
#打印（n、op、cl）
如果opcl：
ans=self.generate（C+['）']，n，ans，op，cl+1）
其他：
ans.append（“”.join（C））
返回ans

设n=2

如果我们构造一个递归树，那么长度将达到

2*n=2*2=4

的第一个字符串是

C=“（”

现在

的长度为

2*n

但无效

那么，条件呢

len（C）==2*n和self.valid（C）

为

False

现在执行

else

部分，程序将运行无限递归调用

PS：感谢您指出逻辑错误

让n=2