算法刷题打卡021 | 回溯-组合问题

回溯理论基础

第二次看回溯算法了，回溯的基本思路也已经基本掌握，接下来就是需要多做题，将回溯思想贯彻落实！具体理论参考代码随想录 (programmercarl.com)。

回溯的应用场景往往没有其他解题途径，只能枚举，但直接嵌套循环枚举只适用于循环层数较少的场景，通过在递归中使用for循环，可以实现在树中不断往深层遍历，而回溯是为了让程序能够走向其他路径，类比二叉树，通过纸笔模拟在树中节点的移动，可以更直观地理解回溯思想。

LeetCode 77 组合 

题目链接：77. 组合 - 力扣（Leetcode）

 组合问题是回溯法运用的经典题目，代码实现也是基本模板了：

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        res, path = [], []

        def backtracking(start_Index):
            if len(path) == k:
                res.append(path.copy())
                return  # 叶节点，收集结果
            end_idx = n - (k - len(path)) + 1   # range左闭右开，所以需要额外加1
            for i in range(start_Index,  end_idx + 1):
                path.append(i)  # 处理节点
                backtracking(i + 1)
                path.pop()  # 回溯
        
        backtracking(1)
        return res

另外还做了两道组合总和题目，进一步复习组合类问题的解题思路。

LeetCode 39 组合总和

题目链接：39. 组合总和 - 力扣（Leetcode）

 这道题和77 组合题目很像，代码实现也差不多，收集结果的判断条件由path的长度改为当前的path中元素的和。但具体实现时一开始卡在去重上，因为根据题意，一个元素可以被无限次使用，因此把for循环写成了每次都可以从0开始遍历candidates。这样实现的代价是result中会有重复的结果（元素顺序不同，但对组合来说是一样的）。解决办法是传入一个for循环开始的下标，它能帮助我们限制每一层后续元素的递归范围，避免获得重复的组合结果。此外，求组合问题不强调元素顺序，可以先排序再处理，更有助于对和大于目标的分支做了剪枝，加快处理速度。

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        candidates.sort()
        path, result = [], []

        def backtracking(start, n, Sum):
            if Sum == target:
                result.append(path[:])
                return
            # for循环从传入的start开始遍历，避免出现重复组合
            for i in range(start, n):
                # 剪枝，没必要再递归下去
                if Sum + candidates[i] > target:
                    break
                # 处理
                path.append(candidates[i])
                Sum += candidates[i]
                # 递归
                backtracking(i, n, Sum)
                # 回溯
                path.pop()
                Sum -= candidates[i]
        
        backtracking(0, len(candidates), 0)
        return result

以上这种实现还有可以优化的空间，比如一般会用目标值target-已加入path中元素的和，代替Sum来作为递归函数的参数。

LeetCode 40 组合总和II

题目链接：40. 组合总和 II - 力扣（Leetcode）

这道题和39的唯一区别是每个元素只能使用一次，此时除了限制for循环起始遍历位置，还要进一步对结果去重，在同一层的遍历中，已遍历过的元素值适时跳过，才能避免result结果出现重复组合。

class Solution:
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        candidates.sort()
        path, result = [], []

        def backtracking(start, n, Sum):
            if Sum == target:
                result.append(path[:])
                return
            # for循环从传入的start开始遍历，避免出现重复组合
            for i in range(start, n):
                # 剪枝，没必要再递归下去
                if Sum + candidates[i] > target:
                    break
                # 去重
                if i > start and candidates[i] == candidates[i-1]:
                    continue
                # 处理
                path.append(candidates[i])
                Sum += candidates[i]
                # 递归
                backtracking(i+1, n, Sum)
                # 回溯
                path.pop()
                Sum -= candidates[i]
        
        backtracking(0, len(candidates), 0)
        return result

为了加深对39 40中这两种去重的理解，之后空闲时画图补充说明。