Question

我写了一个python程序，使用回溯来给出字符串的所有排列：

class Solution(object):
    def permute(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        if nums == None or len(nums) <= 1:
            return [nums]

        res_lst = []
        res = []
        self.permuteHelper(res_lst, nums, res)
        return res_lst

    def permuteHelper(self, res_lst, nums, res):
        if len(res) == len(nums):
            res_lst.append(res)
            return

        for n in nums:
            if n not in res:
                self.permuteHelper(res_lst, nums,res+[n])
                res = res[:-1] #Prune back one node

这个总是超过最大递归限制。因为在每个递归步骤中我将结果列表+ [n]传递给下一个递归调用，我想它最终会到达结束情况len（res）== len（nums）。

Doe有谁知道为什么不发生这种情况？

Answer 1

啊，这很微妙。删除行：

 res = res[:-1] #Prune back one node

它有效。从给定的排列中删除一个数字，这意味着每次执行此操作时，都会为递归添加一个递归级别，因此您必须不断深入。

它也彻底弄乱了排列。

Answer 2

这是排列的迭代实现：

import itertools

def permutations(*args):
  res = list(args)
  if len(res) > 0:
    for n in itertools.count():
      yield tuple(res)
      i = x = 2
      while n % x == x - 1:
        i += 1
        x *= i
      if i > len(res):
        break
      j = (n + 1) % x * i // x
      res[-i], res[-j] = res[-j], res[-i]
      res[1 - i:] = res[:-i:-1]

请注意，这对重复值没有任何特殊处理。

为什么这个字符串排列代码超过了递归限制？

2 个答案: