Leetcode| 39. 组合总和、40. 组合总和II、131.分割回文串 Day27

39. Combination Sum

回溯

因为每个数字可以被无限次使用，所有递归传入的startIndex仍为i

class Solution:
    def __init__(self):
        self.res = []
        self.path = []

    def backtracking(self, candidates, target, curSum, startIndex):
        # 终止条件
        if curSum >= target:
            if curSum == target:
                self.res.append(self.path.copy())
            return
        
        for i in range(startIndex, len(candidates)):
            self.path.append(candidates[i])
            curSum += candidates[i]
            self.backtracking(candidates, target, curSum, i)    # 递归，startIndex仍然为i
            curSum -= candidates[i]     # 回溯
            self.path.pop()

    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        self.backtracking(candidates, target, 0, 0)
        return self.res

回溯，剪枝优化

先将数组排序，已经知道下一层的sum会大于target，就没有必要进入下一层递归了.
对总集合排序之后，如果下一层的sum（就是本层的 sum + candidates[i]）已经大于target，就可以结束本轮for循环的遍历。

class Solution:
    def __init__(self):
        self.res = []
        self.path = []

    def backtracking(self, candidates, target, curSum, startIndex):
        # 终止条件
        if curSum == target:
            self.res.append(self.path.copy())
            return
        
        for i in range(startIndex, len(candidates)):
            # 剪枝
            if curSum + candidates[i] > target: break
            
            self.path.append(candidates[i])
            curSum += candidates[i]
            self.backtracking(candidates, target, curSum, i)    # 递归，startIndex仍然为i
            curSum -= candidates[i]     # 回溯
            self.path.pop()

    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        candidates.sort()       # 先排序
        self.backtracking(candidates, target, 0, 0)
        return self.res

---

40. Combination Sum II

回溯

每个candiate只有用一次
必须先对数组排序，同一数层上如果相邻两个元素相等并且前一个使用过，则需要跳过

class Solution:
    def __init__(self):
        self.path = []
        self.res = []
        # self.used = []

    def backtracking(self, candidates, target, curSum, startIndex, used):
        if curSum >= target:
            if curSum == target:
                self.res.append(self.path.copy())
            return

        for i in range(startIndex, len(candidates)):
            # 去重
            # used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
            # used[i - 1] == false，说明同一树层candidates[i - 1]使用过
            # 要对同一树层使用过的元素进行跳过
            if i > 0 and candidates[i] == candidates[i - 1] and used[i - 1] == False:
                continue

            self.path.append(candidates[i])
            curSum += candidates[i]
            used[i] = True
            self.backtracking(candidates, target, curSum, i + 1, used)
            used[i] = False
            curSum -= candidates[i]
            self.path.pop()

    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        used = [False] * len(candidates)
        candidates.sort()   # 树层去重的话，需要对数组排序！
        self.backtracking(candidates, target, 0, 0, used)
        return self.res

---

131. Palindrome Partitioning

比较难，借助图理解

class Solution:
    def __init__(self):
        self.path = []
        self.res = []

    def backtracking(self, s_list, startIndex):
        # 终止条件
        if startIndex >= len(s_list):
            self.res.append(self.path.copy())
            return

        for i in range(startIndex, len(s_list)):
            s_cut = s_list[startIndex: i + 1]
            if s_cut == s_cut[::-1]:    # 是回文串
                self.path.append(''.join(s_cut))
            else:
                continue                # 相当于重新走一条新树枝
            self.backtracking(s_list, i + 1)
            self.path.pop()         # 回溯

    def partition(self, s: str) -> List[List[str]]:
        self.backtracking(list(s), 0)
        return self.res