代码训练营 Day 27 ｜ 回溯 03

1、

39. Combination Sum

组合问题：给一系列找和为target

给定的数字有没有范围（例如1-9，还是正整数，还是有0/负数的情况）

给定的数字取值有没有要求（能不能重复取，还是限制了取数的个数（只能取5个））

本题：本题是 集合里元素可以用无数次，那么和组合问题的差别 其实仅在于 startIndex上的控制

注意：⚠️

本题还需要startIndex来控制for循环的起始位置，对于组合问题，什么时候需要startIndex呢？

我举过例子，如果是一个集合来求组合的话，就需要startIndex，例如：77.组合 (opens new window)，216.组合总和III (opens new window)。

如果是多个集合取组合，各个集合之间相互不影响，那么就不用startIndex，例如：17.电话号码的字母组合(opens new window)

注意以上我只是说求组合的情况，如果是排列问题，又是另一套分析的套路，后面我在讲解排列的时候会重点介绍。

 1）Determining Recursive Function Arguments

vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& candidates, int target, int sum, int startIndex)

2）Determination of termination conditions

if (sum > target) {
    return;
}
if (sum == target) {
    result.push_back(path);
    return;
}

3）single-level search process

for (int i = startIndex; i < candidates.size(); i++) {
    sum += candidates[i];
    path.push_back(candidates[i]);
    backtracking(candidates, target, sum, i); // 关键点:不用i+1了，表示可以重复读取当前的数
    sum -= candidates[i];   // 回溯
    path.pop_back();        // 回溯
}

class Solution(object):
    def combinationSum(self, candidates, target):
        """
        :type candidates: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        result = []
        self.backtracking(candidates, target, 0, 0, [], result)
        return result
    
    def backtracking(self, candidates, target, total, startIndex, path, result):
        if total > target:
            return 
        if total == target:
            result.append(path[:])
            return
        
        for i in range(startIndex, len(candidates)):
            total += candidates[i]
            path.append(candidates[i])
            self.backtracking(candidates, target, total, i, path, result)
            total -= candidates[i]
            path.pop()# 这里又可以用pop

 

2、

​​​​​​40. Combination Sum II

candidates有重复元素+结果里不能有重复元素

深度上可以，广度上需要去重

class Solution(object):
    def combinationSum2(self, candidates, target):
        """
        :type candidates: List[int]
        :type target: int
        :rtype: List[List[int]]
        """

        # Sort the candidates.
        candidates.sort()

        result = []
        self.backtracking(candidates, target, 0,0, [], result)
        return result
    
    def backtracking(self, candidates, target, total, startIndex, path, result):
        #if total > target:
        #    return 
        if total == target:
            result.append(path[:])
            return
    
    for i in range(startIndex, len(candidates)):
        # Remove duplicates
        #if (candidates[startIndex] == candidates[startIndex-1]):
        #    continue

        if i > startIndex and candidates[i] == candidates[i - 1]:
            continue

        if total + candidates[i] > target:
            break


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

1. if i > startIndex and candidates[i] == candidates[i - 1]: continue:

   • 此条件检查当前候选值是否等于前一个候选值 (candidates[i] == Candidates[i - 1]) 以及当前候选值是否不是当前分支中的第一个候选值 (i > startIndex)。
   • 如果两个条件都满足，则意味着我们已经在该分支的前面考虑了具有相同值的组合，并且我们应该跳过该候选值以避免结果重复。
   • 此条件有助于消除结果中的重复组合。如果没有它，结果中可能会出现多个相同的组合。

2. if total + candidates[i] > target: break:

   • 此条件检查将当前候选值添加到 中是否total会超过目标值。
   • 如果添加当前候选会使total超出目标，则继续探索的这个分支是没有意义的，因为可以保证总和无法达到目标。
   • 通过在满足此条件时尽早退出循环，可以节省不必要的计算并提高算法的效率。

3、

131. Palindrome Partitioning

代码随想录

我列出如下几个难点：

• 切割问题可以抽象为组合问题
• 如何模拟那些切割线
• 切割问题中递归如何终止
• 在递归循环中如何截取子串
• 如何判断回文

  1）Determining Recursive Function Arguments

vector<vector<string>> result;
vector<string> path; // 放已经回文的子串
void backtracking (const string& s, int startIndex) {

2）Determination of termination conditions

从树形结构的图中可以看出：切割线切到了字符串最后面，说明找到了一种切割方法，此时就是本层递归的终止条件。

那么在代码里什么是切割线呢？

void backtracking (const string& s, int startIndex) {
    // 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
    if (startIndex >= s.size()) {
        result.push_back(path);
        return;
    }
}

3）single-level search process

[startIndex, i] 就是要截取的子串

首先判断这个子串是不是回文，如果是回文，就加入在vector<string> path中，path用来记录切割过的回文子串。

for (int i = startIndex; i < s.size(); i++) {
    if (isPalindrome(s, startIndex, i)) { // 是回文子串
        // 获取[startIndex,i]在s中的子串
        string str = s.substr(startIndex, i - startIndex + 1);
        path.push_back(str);
    } else {                // 如果不是则直接跳过
        continue;
    }
    backtracking(s, i + 1); // 寻找i+1为起始位置的子串
    path.pop_back();        // 回溯过程，弹出本次已经添加的子串
}

注意切割过的位置，不能重复切割，所以，backtracking(s, i + 1); 传入下一层的起始位置为i + 1。

class Solution(object):
    def partition(self, s):
        """
        :type s: str
        :rtype: List[List[str]]
        """
        result = []
        self.backtracking(s, 0, [], result)
        return result

    
    def backtracking(self, s, startIndex, path, result):
        # Base Case
        if startIndex == len(s):
            result.append(path[:])
            return
        
        # single recursion logic
        for i in range(startIndex, len(s)):
            # 此次比其他组合题目多了一步判断：
            # 判断被截取的这一段子串([start_index, i])是否为回文串
            if self.is_palindrome(s, startIndex, i):
                path.append(s[startIndex: i+1])
                self.backtracking(s, i+1, path, result)
                path.pop()



    
    def is_palindrome(self, s, start, end):
        i = start
        j = end
        while i < j:
            if s[i] != s[j]:
                return False
            i += 1
            j -= 1
        return True