Day 27 代码随想录 组合总和

---

39. 组合总和

  题目链接：39. 组合总和
 

  这里再次回顾一下回溯算法模板

1. 参数确定
2. 终止条件
3. 单层递归逻辑

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        res=[]
        path=[]
        Sum=0
        def backtracking(candidates, target,Sum,start_index):
            if Sum > target:
                return
            if Sum==target:
                res.append(path[:])
                return
            for i in range(start_index,len(candidates)):
                path.append(candidates[i])
                Sum+=candidates[i]
                backtracking(candidates,target,Sum,i)
                Sum-=candidates[i]
                path.pop()
        backtracking(candidates,target,Sum,0)
        return res

注意事项

1.深拷贝问题
2.减去加入的值

剪枝前需要排序

if sum_ + candidates[i] > target: 
    return 

40. 组合总和 II

  题目链接：组合总和 II
 

  这题的关键就是去重，需要使用一个 ** used**数组来记录是否与之前的数字相同，只有树层的剪枝。

class Solution:
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        path=[]
        res=[]
        used=[0]*len(candidates)
        def backtracking(candidates,target,Sum,start_index,used):
            candidates.sort()
            if Sum>target:
                return
            if Sum==target:
                res.append(path[:])
                return
            # 递归
            for i in range(start_index,len(candidates)):
                if i>0 and candidates[i]==candidates[i-1] and used[i-1]==False:
                    continue
                #剪枝
                if Sum+candidates[i]>target :
                    return
                Sum+=candidates[i]
                path.append(candidates[i])
                used[i]=True
                # 回溯
                backtracking(candidates,target,Sum,i+1,used)
                used[i]=False
                Sum-=candidates[i]
                path.pop()
        backtracking(candidates,target,0,0,used)
        return res

131. 分割回文串

  题目链接：131. 分割回文串

 
已经不是很懂了

class Solution:
    def partition(self, s: str) -> List[List[str]]:
        res=[]
        path=[]
        def backtracking(s,start_index):
            if start_index >= len(s):
                res.append(path[:])
                return
            for i in range(start_index,len(s)):
                temp = s[start_index:i+1]
                if temp ==temp[::-1]:
                    path.append(temp)
                    backtracking(s,i+1)
                    path.pop()
                else:
                    continue
        backtracking(s,0)
        return res

·start_index在每次递归的时候都在变，因为递归属于纵向遍历了