leetcode hot100 39. 组合总和 medium 递归回溯

每个数字可以无限次使用 → 递归时可以继续选当前数字。
组合不考虑顺序 → 递归时只能往后选（避免重复）。
结果是所有和为 target 的组合

python 复制代码

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        res = []

        # 剩余目标值 = target - sum(tmp)
        def backtrack(candidates, tmp, remain):  #（待选列表，已有排列）

            if remain == 0:  # 剩余目标为0 
                res.append(tmp)
                return

            if remain < 0:  # 剩余目标 < 0 → 无效
                return

            # 依次选择待选列表的元素，进入排列。
            for i in range(len(candidates)):
                # 同一个数字可以无限制重复被选取, 下一轮还得包括candidates[i]
                backtrack(candidates[i:], tmp + [candidates[i]], remain - candidates[i])  # 子集顺序不重要，只能往后选
            
        
        backtrack(candidates, [], target)
        return res

在 Python 中，+ 拼接列表和 [:] 切片都会创建一个新列表，时间复杂度为 O(K)O(K)O(K)（KKK 为列表长度）。这意味着每一轮递归都多出了一个 O(N)O(N)O(N) 的操作。

时间复杂度约为 O(S×N)O(S \times N)O(S×N)

其中 SSS 是所有可行解组合的总长度。在 LeetCode 的约束下，这通常是可接受的。

空间复杂度

假设在递归的每一层都选择了数组中的最小值 m=min⁡(candidates)m = \min(candidates)m=min(candidates)

DDD 层递归后，D×m≈targetD \times m \approx targetD×m≈target

最大深度 (Depth)，递归树深度：
D≈targetmin(candidates)D \approx \frac{target}{min(candidates)}D≈min(candidates)target

递归系统栈空间：O(D)O(D)O(D)

分支因子 (Width)，每一层最多有 NNN 个分支：
N=len(candidates)N = len(candidates)N=len(candidates)

每层会创建新的切片列表：最长为 NNN

新的 tmp 路径列表：最长为 DDD

所以：
D×(N+D)D \times (N + D)D×(N+D)

由于通常 NNN 是数组长度，属于常数或较小值：

切片回溯空间复杂度 ： O(D⋅N)O(D \cdot N)O(D⋅N)