用心感受♥回溯在Python3的应用——需要剪枝的

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

		输入：candidates = [2,3,6,7], target = 7,
		所求解集为：
		[
		  [7],	
		  [2,2,3]
		]

数字可以无限制重复被选取
产生重复的原因是：在每一个结点，做减法，展开分支的时候，由于题目中说 每一个元素可以重复使用，我们考虑了 所有的 候选数，因此出现了重复的列表。

class Solution:
    def combinationSum(self, nums: List[int], target: int) -> List[List[int]]:
        res = []
        if not nums: return [];

        def dfs(temp, num, temptar):
            if temptar == 0:
                res.append(temp[:]);
                return
            if temptar < 0:
                return
            else:
                for i in range(num, len(nums)):
                    temptar = temptar - nums[i]
                    temp.append(nums[i]);
                    dfs(temp, i , temptar);//元素可以重复使用，所以从当次开始继续向下搜索
                    temp.pop();
                    temptar = temptar + nums[i]

        dfs([],0,target);
        return res;

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

	输入：candidates = [2,3,6,7], target = 7,
	所求解集为：
	[
	  [7]
	]

每个数字在每个组合中只能使用一次，减去左边树使用过的

class Solution:
    def combinationSum(self, nums: List[int], target: int) -> List[List[int]]:
        res = []
        if not nums: return [];

        def dfs(temp, num, temptar):
            if temptar == 0:
                res.append(temp[:]);
                return
            if temptar < 0:
                return
            else:
                for i in range(num, len(nums)):
                    temptar = temptar - nums[i]
                    temp.append(nums[i]);
                    dfs(temp, i+1 , temptar);//元素可以不可以重复使用，所以从下一个开始继续向下搜索
                    temp.pop();
                    temptar = temptar + nums[i]

        dfs([],0,target);
        return res;

给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

	输入: candidates = [10,1,2,7,6,1,5], target = 8,
	所求解集为:
	[
	  [1, 7],
	  [1, 2, 5],
	  [2, 6],
	  [1, 1, 6]
	]

数组中有重复数，结果不重复，不按顺序，只使用一次。
先给数组排序，减去相邻树和左边树使用过的

class Solution:
    def combinationSum2(self, nums: List[int], target: int) -> List[List[int]]:
        nums.sort()
        res = []
        if not nums: return []
        def dfs(temp, num, temptar):
            if temptar == 0:
                res.append(temp[:]);
                return
            if temptar < 0 :
                return
            else:
                for i in range(num, len(nums)):
                    if i > num and nums[i - 1] == nums[i]://减去相同元素的树
                        continue
                    temptar = temptar - nums[i]
                    temp.append(nums[i]);
                    dfs(temp, i+1, temptar);
                    temp.pop();
                    temptar = temptar + nums[i]

        dfs([], 0, target);
        return res;

90.子集II

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