算法训练营

39. 组合总和

题目链接: 39. 组合总和
文档讲解： 代码随想录
题目难度：中等

思路:递归法
时间复杂度：O(n*2^n)；空间复杂度：O(n)
下面展示 代码：

class Solution:
    def __init__(self) -> None:
        self.res = []
    def backtracking(self, candidates, target, start, sum,s):
        if sum == target:
            self.res.append(s[:])
            return
        if sum > target:
            return
        for i in range(start, len(candidates)):
            # 剪枝版
            if sum + candidates[i] > target:
                continue
            sum += candidates[i]
            s.append(candidates[i])
            if sum > target:
                continue
            else:
                self.backtracking(candidates, target, i, sum,s)
                sum -= candidates[i]
                s.pop()
                
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        s = []
        sum = 0
        # 剪枝版
        candidates.sort()
        self.backtracking(candidates, target, 0, sum, s)
        return self.res

40.组合总和II

题目链接: 40.组合总和II
文档讲解： 代码随想录
题目难度：中等
思路: 同上一题类似，区别在于不能重复使用数组元素，因此需要判断相同元素不在同一树层
时间复杂度：O(n*2^n)；空间复杂度：O(n)
代码如下

class Solution:
    def __init__(self) -> None:
        self.res = []
    def backtracking(self, candidates, target, start, sum,s):
        if sum == target:
            self.res.append(s[:])
            return
        for i in range(start, len(candidates)):
            if sum + candidates[i] > target:
                break
            if i > start and candidates[i] == candidates[i - 1]:  # 此处加上i > start条件，表示是同一树层
                continue
            else:
                sum += candidates[i]
                s.append(candidates[i])
                self.backtracking(candidates, target, i + 1, sum,s)  # 不使用重复的字符，即为i+1
                sum -= candidates[i]
                s.pop()
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        s = []
        sum = 0
        # 剪枝版
        candidates.sort()
        self.backtracking(candidates, target, 0, sum, s)
        return self.res

131.分割回文串

题目链接: 131.分割回文串
文档讲解： 代码随想录
题目难度：中等
思路: 需要加一个判断回文串函数，利用双指针即可解决
时间复杂度：O(n*2ⁿ)；空间复杂度：O(n²)
代码如下

class Solution:
    def ispalindrome(self, s, left, right):
        i,j = left, right
        while i < j:
            if s[i] != s[j]:
                return False
            i += 1
            j -= 1
        return True
    def backtracking(self, s, start, path, res):
        if start == len(s):
            res.append(path[:])
            return
        for i in range(start, len(s)):
            if self.ispalindrome(s, start, i):
                path.append(s[start:i + 1])
                self.backtracking(s, i + 1, path, res)
                path.pop()
    def partition(self, s: str) -> List[List[str]]:
        if len(s) == 1:
            return [[s]]
        else:
            res = []
            self.backtracking(s, 0, [], res)
            return res