代码随想录算法训练营第二十六天| 39. 组合总和 40.组合总和II 131.分割回文串

文档讲解：代码随想录

视频讲解：代码随想录B站账号

状态：看了视频题解和文章解析后做出来了

39. 组合总和

class Solution:
    def backtracking(self, candidates, target, path, result, startindex):
        if sum(path) > target:
            return
        if sum(path) == target:
            result.append(path[:])

        for i in range(startindex, len(candidates)):
            path.append(candidates[i])
            self.backtracking(candidates, target, path, result, i)
            path.pop()

        return result

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

 回溯三步曲

1. 确定函数参数，candidates和target为题目input，path记录当前组合，result为结果集，startindex控制循环开始的下标。

2. 确定终止条件：当path的总和大于target直接return，这个是剪枝。当path的总和等于target，把path加入到结果集中。

3. 确定单层逻辑：for循环的起始点为startindex，终止点为candidates的长度，保证从起始点一直遍历到input的结尾。backtracking的时候，和之前题目不同，startindex传入的是它自己，没有+1。这是因为题目说同一个元素可以使用多次，所以当前元素是可以再次append到path里面的。

 时间复杂度: O(n * 2^n)

 空间复杂度: O(target)

40.组合总和II

class Solution:
    def backtracking(self, candidates, target, path, result, startindex):
        if sum(path) > target:
            return
        if sum(path) == target:
            result.append(path[:])
            return

        for i in range(startindex, len(candidates)):
            if i > startindex and candidates[i] == candidates[i-1]:
                continue

            path.append(candidates[i])
            self.backtracking(candidates, target, path, result, i+1)
            path.pop()

        return result

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

思路和上一题类似，区别是题目规定一个元素只能用一次，而且结果集需要去重。

一个元素只能用一次，那么每次递归的时候startindex传入的值就是当前index+1

去重有两种方式：

1. 当把path加入到结果集中，判断path是否存在于结果集中。这种方式会导致超时。

2. 树层的维度上进行去重。假设题目为[1,1,2]，target=3，那么为了避免有两个[1,2]，在树层遍历到第二个1的时候就应该直接跳过。见下图：

代码中，就是当i>startindex且candidates[i] == candidates[i-1]的时候continue，只有当i>startindex才证明这是最底层的循环（树层）而非树枝。

时间复杂度: O(n * 2^n)

 空间复杂度: O(n)

131.分割回文串

class Solution:
    def isPalindrome(self, string):
        left, right = 0, len(string)-1
        while left < right:
            if string[left] != string[right]:
                return False
            left += 1
            right -= 1
        return True

    def backtracking(self, s, path, result, startindex):
        if startindex == len(s):
            result.append(path[:])
            return

        for i in range(startindex, len(s)):
            if self.isPalindrome(s[startindex:i+1]):
                path.append(s[startindex:i+1])
                self.backtracking(s, path, result, i+1)
                path.pop()
            else:
                continue
        
        return result
                

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

1. 参数不多赘述了，老几样

2. 终止条件：本题中，startindex就是分割线，当分割线等于s的长度，path加入结果集，返回。

3. 单层逻辑：分割的字符串其实就是s[startindex:i+1]，因为startindex在树层维度上是不变的，但i是递增的。我们还需要构建一个是否为回文字符串的函数用来判断，如果是回文则将分割的字符串s[startindex:i+1]加入到path中，否则continue到下一个循环（i++）。

时间复杂度: O(n * 2^n)

 空间复杂度: O(n)