回溯基础算法

1. 不重复元素的子集枚举

对应leetcode 78题

class Solution(object):
    def subsets(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        stack = []
        ret = []

        def compute(stack, seq):
            ret.append(stack[:])
            for i in range(seq, len(nums)):
                stack.append(nums[i])
                compute(stack, i + 1)
                stack.pop()
        compute(stack, 0)
        return ret

说明：这里是树上的深度优先搜索的思想。树上无环，无须考虑考虑访问

2. 重复元素子集枚举

对应leetcode 90题

class Solution:
    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
        ret = list()
        nums.sort()
        def dfs(index, stack):
            ret.append(stack[:])
            for i in range(index, len(nums)):
                if i > index and nums[i] == nums[i - 1]:
                    continue
                dfs(i + 1, stack + [nums[i]])
        dfs(0, [])
        return ret

3. 求下一个全排列，元素可以重复

对应leetcode 31

def nextPermutation(self, nums: List[int]) -> None:
    """
    Do not return anything, modify nums in-place instead.
    """
    for i in range(len(nums) - 1, 0, -1):
        if nums[i] > nums[i - 1]:
            nums[i:] = sorted(nums[i:])
            for j in range(i, len(nums)):
                if nums[j] > nums[i - 1]:
                    nums[j], nums[i - 1] = nums[i - 1], nums[j]
                    return
    return nums.sort()