数据结构与算法-回溯算法2之Combination Sum

39. 组合总和
给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的数字可以无限制重复被选取。

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        if not candidates:
            return []
        if target<0:
            return []
        def backtrace(target,current,m):
            if target<0:
                return
            elif target==0:
                res.append(current[:])
                return
        
            for i in range(m,len(candidates)):
                current.append(candidates[i])
                backtrace(target-candidates[i],current,i)
                current.pop()
        res = []
        current = []
        backtrace(target,current,0)
        return res

剪枝
排序，如果加上candidates[i]已经超过target，则无需再考虑之后的元素

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        if not candidates:
            return []
        
        res = []
        curr = []
        candidates.sort()
        self.backtrace(candidates,target,0,res,curr)
        return res

    def backtrace(self,candidates,target,k,res,curr):
        if target<0:
            return
        if target==0:
            res.append(curr[:])
            return
        
        for i in range(k,len(candidates)):
            if target-candidates[i]<0:
                break
            curr.append(candidates[i])
            self.backtrace(candidates,target-candidates[i],i,res,curr)
            curr.pop()

40. 组合总和 II
给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用一次。（可能存在重复数字）
说明：
所有数字（包括目标数）都是正整数。
解集不能包含重复的组合。

class Solution:
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        if not candidates:
            return []
        
        if target<=0:
            return []

        candidates.sort()
        res = []
        curr = []
        self.backtrack(candidates,res,curr,0,target)
        return res
    
    def backtrack(self,candidates,res,curr,k,target):
        if target<0:
            return
        if target==0:
            res.append(curr[:])
            return
        seen = set()
        for i in range(k,len(candidates)):
            if candidates[i] in seen:
                continue
            seen.add(candidates[i])
            num = target-candidates[i]
            if num<0:
                break
            curr.append(candidates[i])
            self.backtrack(candidates,res,curr,i+1,num)
            curr.pop()

216. 组合总和 III
找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。
说明：
所有数字都是正整数。
解集不能包含重复的组合。

class Solution:
    def combinationSum3(self, k: int, n: int) -> List[List[int]]:
        if n<=0:
            return []
        
        res = []
        curr = []
        self.backtrack(n,k,curr,res,1)
        return res
    
    def backtrack(self,n,k,curr,res,m):
        if n<0:
            return
        if n==0 and len(curr)==k:
            res.append(curr[:])
            return
        if len(curr)>=k:
            return

        for i in range(m,10):
            if n-i<0:
                break
            curr.append(i)
            self.backtrack(n-i,k,curr,res,i+1)
            curr.pop()

377. 组合总和 Ⅳ
给定一个由正整数组成且不存在重复数字的数组，找出和为给定目标正整数的组合的个数。

思路：动态规划

class Solution:
    def combinationSum4(self, nums: List[int], target: int) -> int:
        if not nums or target<=0:
            return 0
        
        dp = [0 for _ in range(target+1)]
        dp[0] = 1
        for i in range(1,target+1):
            for num in nums:
                if i-num>=0:
                    dp[i] += dp[i-num]
        
        return dp[target]

进阶：

• 如果给定的数组中含有负数会怎么样？
• 问题会产生什么变化？
• 我们需要在题目中添加什么限制来允许负数的出现？

如果出现了一对相反数，如4和-4，则可以被无限次地、成对添加进去，此时组合个数就失去了意义。
限制：如果有负数参与进来，不能够与已有的正数的组合之和为 0 ；
或者限制负数的使用次数，设计成类似 0-1 背包问题的样子。

参考资料：
https://leetcode-cn.com/problems/combination-sum-iv/solution/dong-tai-gui-hua-python-dai-ma-by-liweiwei1419/