算法学习 day23 回溯算法02

神弥悠
57 阅读4分钟

39. 组合总和

文章讲解

题目：给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 **不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。 对于给定的输入，保证和为 target 的不同组合数少于 150 个。

 

示例 1：

输入： candidates = [2,3,6,7], target = 7
输出： [[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

示例 2：

输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]

示例 3：

输入: candidates = [2], target = 1
输出: []

 

提示：

  • 1 <= candidates.length <= 30
  • 2 <= candidates[i] <= 40
  • candidates 的所有元素 互不相同
  • 1 <= target <= 40

思路：

可以重复选数字，但是答案的组合不能重复。
定义：backtrack除了candidates: List[int], target: int参数，还要使用total记录总和、start记录开始的索引
终止条件：total=target记录答案，total>target跳出递归
单层搜索： for从start开始遍历每个元素，backtrack纵向遍历

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        self.result = []
        self.track = []
        self.backtrack(candidates, target, 0, 0)
        return self.result

    def backtrack(self, candidates: List[int], target: int, total:int, start: int) -> None:
        if total > target:
            return
        elif total == target:
            self.result.append(self.track[:])
            return

        # 遍历
        for i in range(start, len(candidates)):
            self.track.append(candidates[i])

            self.backtrack(candidates, target, total+candidates[i], i) # 可以重复添加i
            self.track.pop()

方法2：剪枝

total+candidates[i]>target直接不进入递归： 如果下一层的sum（就是本层的 sum + candidates[i]）已经大于target，就可以结束本轮for循环的遍历。

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        self.result = []
        self.track = []
        self.backtrack(candidates, target, 0, 0)
        return self.result

    def backtrack(self, candidates: List[int], target: int, total:int, start: int) -> None:
        if  total == target:
            self.result.append(self.track[:])
            return

        # 遍历
        for i in range(start, len(candidates)):
            if total + candidates[i] > target:  # 
                continue
            self.track.append(candidates[i])

            self.backtrack(candidates, target, total+candidates[i], i) # 可以重复添加i
            self.track.pop()

40. 组合总和 II

文章讲解

题目：给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用 一次 。

注意： 解集不能包含重复的组合。 

 

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

示例 2:

输入: candidates = [2,5,2,1,2], target = 5,
输出:
[
[1,2,2],
[5]
]

 

提示:

  • 1 <= candidates.length <= 100
  • 1 <= candidates[i] <= 50
  • 1 <= target <= 30

思路：

candidates 中的每个数字在每个组合中只能使用 一次;解集不能包含重复的组合。是指集合内元素是可以重复的（树枝），不同的集合之间不能重复（树层去重）。

首先进行排序，方便树层间去重；回溯函数使用start来避免元素重复，使用total记录当前组合的和，与target比对从而达到终止条件时记录答案；如果total>target需要进行剪枝。for循环迭代时，同一个树层，不能出现重复的元素，通过candidates[i]==candidates[i-1]条件跳过重复的元素。

class Solution:
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        self.result = []
        self.track = []
        candidates = list(sorted(candidates))
        self.backtrack(candidates, target, 0, 0)
        return self.result

    def backtrack(self, candidates: List[int], target: int, total:int, start:int ) -> List[List[int]]:
        if total > target:
            return

        if total == target:
            self.result.append(self.track[:])
            return


        for i in range(start, len(candidates)):
            if i > start and candidates[i] == candidates[i-1]:
                continue
                
            self.track.append(candidates[i])

            self.backtrack(candidates, target, total+candidates[i], i+1)
            self.track.pop()

131. 分割回文串

文章讲解

题目：给你一个字符串 s，请你将 **s **分割成一些子串，使每个子串都是 ****回文串。返回 s 所有可能的分割方案。

  示例 1：

输入： s = "aab"
输出： [["a","a","b"],["aa","b"]]

示例 2：

输入： s = "a"
输出： [["a"]]

提示：

  • 1 <= s.length <= 16
  • s 仅由小写英文字母组成
class Solution:
    def partition(self, s: str) -> List[List[str]]:
        self.result = []
        self.track = []
        self.backtrack(s, 0)
        return self.result

    def backtrack(self, s:str, start:int)->None:
        # 终止条件：start>= len(s)
        if start >= len(s):
            self.result.append(self.track[:])
            return 
        
        for i in range(start, len(s)):
            # 选择
            if self.isPalindrome(s, start=start, end=i):
                # 如果是回文串，加入到track
                self.track.append(s[start:i+1])
            else:
                continue
            # 回溯
            self.backtrack(s, i+1)

            # 撤销选择
            self.track.pop()


    def isPalindrome(self,s:str,start:int, end:int)->bool:
        if start > end:
            return False

        p, q = start, end
        while p < q:
            if s[p] == s[q]:
                p += 1
                q -= 1
            else:
                return False

        return True
avatar
文章
阅读
粉丝