（2）回溯算法团灭子集、组合、排列问题 -- 元素有重不可复选

回溯算法团灭子集、组合、排列问题
根据元素是否重复和是否可复选，分为以下三种变体：
1、元素无重不可复选
2、元素有重不可复选
3、元素无重可复选

该篇给出第二种情况的代码，另外两种的实现见上方变体链接。

class RepeatAndSingle:
    """
    元素有重不可复选
    """
    def subsets(self, nums: List[int]) -> List[List[int]]:
        """
        子集问题
        :param nums:
        :return:
        """
        self.res = []
        self.track = []
        # 先排序
        nums = sorted(nums)
        self.s_backtrack(nums, 0)
        return self.res

    def s_backtrack(self, nums, start):
        #  前序位置，每个节点的值都是⼀个⼦集
        self.res.append(self.track[:])

        for i in range(start, len(nums)):
            # 在这里剪枝
            if i > start and nums[i] == nums[i-1]:
                continue

            # 做选择
            self.track.append(nums[i])

            # 通过 start 参数控制树枝的遍历，避免产⽣重复的⼦集
            self.s_backtrack(nums, i+1)

            # 撤销选择
            self.track.pop()

    def combination(self, nums: List[int], k: int) -> List[List[int]]:
        """
        组合问题
        :param nums:
        :param k:
        :return:
        """
        self.res = []
        self.track = []
        # 先排序
        nums = sorted(nums)
        self.c_backtrack(nums, 0, k)
        return self.res

    def c_backtrack(self, nums, start, k):
        #  base case
        if len(self.track) == k:
            self.res.append(self.track[:])
            return

        for i in range(start, len(nums)):
            # 在这里剪枝
            if i > start and nums[i] == nums[i - 1]:
                continue

            # 做选择
            self.track.append(nums[i])

            # 通过 start 参数控制树枝的遍历，避免产⽣重复的⼦集
            self.c_backtrack(nums, i+1, k)

            # 撤销选择
            self.track.pop()

    def permute(self, nums: List[int]) -> List[List[int]]:
        """
        排列问题
        :param nums:
        :return:
        """
        self.res = []
        self.track = []
        self.used = [False] * len(nums)
        self.p_backtrack(nums)
        return self.res

    def p_backtrack(self, nums):
        #  base case
        if len(self.track) == len(nums):
            self.res.append(self.track[:])
            return

        for i in range(0, len(nums)):
            # 已经存在 track 中的元素，不能重复选择
            if self.used[i]:
                continue

            # 新添加的剪枝逻辑，固定相同的元素在排列中的相对位置
            if i > 0 and nums[i] == nums[i - 1] and not self.used[i-1]:
                # 如果前⾯的相邻相等元素没有⽤过，则跳过
                continue

            # 做选择
            self.used[i] = True
            self.track.append(nums[i])

            # 通过 start 参数控制树枝的遍历，避免产⽣重复的⼦集
            self.p_backtrack(nums)

            # 撤销选择
            self.used[i] = False
            self.track.pop()