Question

例如，如果nums = [1,2,3]，解决方案是：

[
  [3],
  [1],
  [2],
  [1,2,3],
  [1,3],
  [2,3],
  [1,2],
  []
]

我的代码如下：

class Solution(object):

"""
:type nums: List[int]
:rtype: List[List[int]]
"""
def subsets(self, nums):
    if not nums or len(nums) == 0:
        return 


    nums.sort()

    subset = []
    results = [[]]
    self.subsetHelper(nums, 0, subset, results)

    return results

def subsetHelper(self, nums, startIndex, subset, results):
    # subset is 1D list store elements that create results
    # results is 2D list that store results created

    results.append(subset)

    for i in range(startIndex, len(nums)):
        subset.append(nums[i])
        # recursion:
        self.subsetHelper(nums, i+1, subset, results)
        # backtracking:
        subset.pop()

虽然[1,2,3]的答案是：

[[],[3],[2],[2,3],[1],[1,3],[1,2],[1,2,3]]

我的回答是：

[[],[],[],[],[],[],[],[],[]]

有人可以告诉我哪里出错了，以及如何修改它以获得[ [3], [1], [2], [1,2,3], [1,3], [2,3], [1,2], [] ]

感谢。

Answer 1

您可以使用它来生成给定列表的所有子列表：

list = [1,2,3]

def subset(i):
    finallist = []
    for first in range(0,len(i)+1):
        for last in range(first+1,len(i)+1):
            templist = []
            for index in range(first,last):
                templist.append(i[index])
            finallist.append(templist)
    return finallist


print(subset(list))

然而，这不包括[1,3]，因为这不是真正的子列表。要制作列表的所有可能组合，请参阅：

Making all possible combinations of a list in python

Answer 2

您的案例中的问题是列表可变。

为了简要解释可变性及其如何导致问题，请考虑以下代码 -

x = something # mutable type
x = y
print x
# some statement that operates on y
print x # might print something different

现在，在我们的例子中，result中的元素可以被认为与上面示例中的x类似，subset代表y的模拟。因此，在subset中进行更改会对`result。

进行更改

解决方案 -

好吧，由于我们的问题是由于列表可变而引起的，将subset转换为元组（这是不可变的）将有助于解决问题。只需将result.append(subset)更改为result.append(tuple(subset))即可完成此操作。

最后，如果您真的希望result拥有list而不是元组，则可以使用results.append(list(tuple(subset)))。这将创建一个元组点亮，与subset没有任何关系，因此不会因为可变性而发生危险。

额外您可能希望将result初始化为result=[]而不是result=[[]]。在后面的例子中，它会在列表列表中添加一个额外的空列表。:)

子集一组不同的整数，nums，返回所有可能的子集python

2 个答案: