组数总和一

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

candidates 中的数字可以无限制重复被选取。

说明：

所有数字（包括 target）都是正整数。
解集不能包含重复的组合。 

示例 1:

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

示例 2:

输入: candidates = [2,3,5], target = 8,
所求解集为:
[
[2,2,2,2],
[2,3,3],
[3,5]
]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/combination-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
回溯加剪枝

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        size=len(candidates)
        if(size ==0):
            return []
        candidates.sort();
        result=[]
        self.recursion([],0,target,candidates,size,result)
        return result
    def recursion(self,path,start,residue,candidates,size,result):
            if(residue==0):
                result.append(path[:])
                
                 
            
            for i in range(start,size):
                residue2=residue-candidates[i]
                if(residue2<0):
                    break
                path.append(candidates[i])
                self.recursion(path,i,residue2,candidates,size,result)
                path.pop()

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        size=len(candidates)
        if(size ==0):
            return []
        #candidates.sort();
        result=[]
        self.recursion([],0,target,candidates,size,result)
        return result
    def recursion(self,path,start,residue,candidates,size,result):
            if(residue==0):
                result.append(path[:])
                
            if(residue<0):
                    return      
            
            for i in range(start,size):
                residue2=residue-candidates[i]
                
                path.append(candidates[i])
                self.recursion(path,i,residue2,candidates,size,result)
                path.pop()

动态规划

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        dic={}
        size=len(candidates)
        for i in range(1,target+1):
            dic[i]=[]
            for j in candidates:
                if(i==j):
                    dic[i].append([j])
                elif(i>j):
                    for k in dic[i-j]:
                        x=k[:]
                        x.append(j)
                        x.sort()
                        if(x not in dic[i]):
                            dic[i].append(x)
        return dic[target]

思路也很简单就是依次求出从1到target的在candidates 中的所有组合，后面的组合由前一个组合加candidate中的数组成。

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        dic={}
        size=len(candidates)
        for j in candidates:
            
            for i in range(1,target+1):
                if(j==candidates[0]):
                    dic[i]=[]
                if(i==j):
                    dic[i].append([j])
                elif(i>j):
                    for k in dic[i-j]:
                        x=k[:]
                        x.append(j)
                        # x.sort()
                        dic[i].append(x)
                            
        return dic[target]

又改进了下发现将两个遍历交换次序，就不会再出现重复的组合了，这样就避免了去重及其之前的排序工作，这样的时间复杂度会更低。

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        #candidates.sort()
        dp = [[] for i in range(target+1)]
        dp[0].append([])
        for c in candidates:
            for i in range(1,target+1):
                if i>=c:
                    for pre in dp[i-c]:
                        dp[i].append(pre+[c])
        # print(dp)
        return dp[target]