Leetcode DAY 27：组合总和 and 组合总和II and 分割回文串

最新推荐文章于 2024-08-10 22:52:22 发布

Petal990912

最新推荐文章于 2024-08-10 22:52:22 发布

阅读量93

点赞数

文章标签： leetcode 算法职场和发展

本文链接：https://blog.csdn.net/qq_44189622/article/details/128341345

版权

39. 组合总和

递归的start不用+1

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

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

40.组合总和II

不能重复使用递归的start要+1

class Solution:
    def __init__(self):
        self.path = []
        self.res = []
        self.sum = 0
    def backtracking(self, candidates: List[int], target: int, start: int):
        if self.sum > target:
            return
        if self.sum == target:
            self.res.append(self.path[:])
            return
        for i in range(start, len(candidates)):
            # 去除重复的
            if i > start and candidates[i] == candidates[i - 1]:
                continue
            self.path.append(candidates[i])
            self.sum += candidates[i]
            self.backtracking(candidates, target, i + 1)
            self.path.pop()
            self.sum -= candidates[i]

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

131.分割回文串

采用逆序字符串的方式判断是否是回文串

class Solution:
    def __init__(self):
        self.path = []
        self.res = []
    def backtracking(self, s: str, start: int):
        # 分割到最后一个字符的位置 说明找到一种
        if start >= len(s):
            self.res.append(self.path[:])
            return
        for i in range (start, len(s)):
            tmp = s[start: i + 1]
            # 判断回文串 正序和逆序相等
            if tmp == tmp[::-1]:
                self.path.append(tmp)
                self.backtracking(s, i + 1)
                self.path.pop()
            else:
                continue
    def partition(self, s: str) -> List[List[str]]:
        self. backtracking(s, 0)
        return self.res