39.组合总和

最新推荐文章于 2022-03-02 08:45:41 发布

TommyLiuZ

最新推荐文章于 2022-03-02 08:45:41 发布

阅读量251

点赞数

分类专栏： leetcode 文章标签：回溯法剪枝 leetcode 算法组合总和

本文链接：https://blog.csdn.net/TommyLiuZ/article/details/115068356

版权

leetcode 专栏收录该内容

62 篇文章

订阅专栏

本文探讨了一种组合总和问题的解决方案，通过比较作者自编的回溯算法与官方提供的优化回溯算法，分析了算法的时间复杂度和空间复杂度。官方方案利用反向思维和剪枝策略，显著提高了运行效率。该问题主要涉及回溯法在求解组合问题中的应用，以及算法优化技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

39.组合总和

1.题目

在这里插入图片描述

2.我的解决方案

自己写的回溯算法，虽然进行了剪枝，但是从运行时间上来看，效果还是不行

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        # 使用回溯法+剪枝函数
        def dfs(candidates, target, begin, path, res):
            if path:
                if sum(path) == target:
                    res.append(path[:])
                if sum(path) > target:  # 剪枝函数
                    return 
            for i in range(candidates.index(begin), len(candidates)):   # 为了去重，看当前的根结点，只能选取根结点本身和后面比他大的数组
                path.append(candidates[i])
                dfs(candidates, target, candidates[i], path, res)
                path.pop()

        res = [] # 结果集合（要去重）
        path = [] # 路径列表
        candidates.sort() # 为了方便进行剪枝，从小到大排列
        dfs(candidates, target, candidates[0], path, res)
        return res

时间复杂度: $O (n!)$
空间复杂度: $O (t a r g e t)$ 最差情况下递归target层

3.官方的解决方案

从运行时间上看，与原方案相比节省了多于一半的时间

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        # 别人写的回溯，采用反向思维，太精妙了
        # remian表示现在路径和和target之间的距离
        def dfs(begin, path, remain):
            for i in range(begin, len(candidates)):
                num = candidates[i]
                if num == remain:
                    path.append(num)
                    res.append(path[:])
                    path.pop()  # 还是得还原状态
                    return
                if num < remain:
                    path.append(num)
                    dfs(i, path, remain-num)    # index用i， 表示从自己的索引开始
                    path.pop()  # 回溯状态还原
                if num > remain:
                    return

        res = []
        path = []
        candidates.sort()   # 排序，减小搜索空间
        dfs(0, path, target)
        return res

时间复杂度: $O (n!)$
空间复杂度: $O (t a r g e t)$ 最差情况下递归target层