Leetcode 39:组合总和(最详细的解法!!!)

给定一个无重复元素的数组 candidates 和一个目标数 target ,找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的数字可以无限制重复被选取。

说明:

  • 所有数字(包括 target)都是正整数。
  • 解集不能包含重复的组合。

示例 1:

输入: candidates = [2,3,6,7], target = 7,
所求解集为:
[
  [7],
  [2,2,3]
]

示例 2:

输入: candidates = [2,3,5], target = 8,
所求解集为:
[
  [2,2,2,2],
  [2,3,3],
  [3,5]
]

解题思路

这个问题可以通过递归回溯的思想来解决。对于candidates=[2,3,6,7]target=7。首先遍历到2,这个时候如果结果中有2的话,那么我们接下来的target=5,依次下去,结果就是:

2 2 2 2

我们发现这个时候target=-1,显然不对,这个时候我们退到上一步,也就是:

2 2 2

这个时候我们的target=1,将剩余3,6,7遍历一遍都没有我们想要的结果。接着再退回到上一步,也就是:

2 2

这个时候我们的target=3,依次遍历3,6,7,我们发现3满足条件,将2,2,3加入到结果中。同理,我们将7加入到结果中。

class Solution:
    def combinationSum(self, candidates, target):
        """
        :type candidates: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        result = list()
        candidates.sort()
        self._combinationSum(candidates, target, 0, list(), result)
        return result
        
    def _combinationSum(self, nums, target, index, path, res):
        if target < 0:
            return

        if target == 0:
            res.append(path)
            return 
            
        for i in range(index, len(nums)):
            self._combinationSum(nums, target-nums[i], i, path+[nums[i]], res)

其实你也发现了,实际上当target < path[-1]的时候我们就应该直接return(因为我们事先对数组进行了排序,后面的元素中不可能出现比path[-1]更小的了),这样我们又优化了这个代码。

class Solution:
    def combinationSum(self, candidates, target):
        """
        :type candidates: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        result = list()
        candidates.sort()
        self._combinationSum(candidates, target, 0, list(), result)
        return result
        
    def _combinationSum(self, nums, target, index, path, res):
        if target == 0:
            res.append(path)
            return 

        if path and target < path[-1]:
            return

        for i in range(index, len(nums)):
            self._combinationSum(nums, target-nums[i], i, path+[nums[i]], res)

我们还可以这样考虑,对于每个数仅考虑放入和不放入两种状态,那么:

class Solution:
    def combinationSum(self, candidates, target):
        """
        :type candidates: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        result = list()
        candidates.sort()
        self._combinationSum(candidates, target, 0, list(), result)
        return result
        
    def _combinationSum(self, nums, target, index, path, res):
        if target == 0:
            res.append(path)
            return 

        if index == len(nums) or (path and target < path[-1]):
            return 

        self._combinationSum(nums, target, index + 1, path, res) # 不放入
        self._combinationSum(nums, target - nums[index], index, path + [nums[index]], res) #放入

注意在放入的时候,我们没有移动index,应该可以放入多次。

同样的,对于递归可以解决的问题,我们都应该思考是不是可以通过迭代解决。

class Solution(object):
    def combinationSum(self, candidates, target):
        """
        :type candidates: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        candidates = sorted(set(candidates))
        result = list()
        stack = [(0, list(), target)]
        cand_len = len(candidates)

        while stack:
            i, path, remain = stack.pop()
            while i < cand_len:
                if path and remain < path[-1]:
                    break
                if candidates[i] == remain: 
                    result.append(path + [candidates[i]])
                stack += [(i, path + [candidates[i]],  remain - candidates[i])]
                i+=1

        return result

我将该问题的其他语言版本添加到了我的GitHub Leetcode

如有问题,希望大家指出!!!

发布了746 篇原创文章 · 获赞 470 · 访问量 86万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 技术黑板 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览