40. Combination Sum II

原创已于 2022-06-02 15:42:33 修改 · 167 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#python #算法 #leetcode

于 2021-04-16 23:27:52 首次发布

leetcode-python 专栏收录该内容

99 篇文章

订阅专栏

这篇博客介绍了一个Python解决方案，用于解决给定候选数数组和目标数，找到所有和为目标数的独特组合。通过深度优先搜索（DFS）实现，避免重复组合。文章提供了两种解法，一种使用集合去重，另一种利用排序简化问题，两者都利用了递归。

40. Combination Sum II

Medium

266587Add to ListShare

Given a collection of candidate numbers (candidates) and a target number (target), find all unique combinations in candidates where the candidate numbers sum to target.

Each number in candidates may only be used once in the combination.

Note: The solution set must not contain duplicate combinations.

Example 1:

Input: candidates = [10,1,2,7,6,1,5], target = 8
Output: 
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

Example 2:

Input: candidates = [2,5,2,1,2], target = 5
Output: 
[
[1,2,2],
[5]
]

Constraints:

1 <= candidates.length <= 100
1 <= candidates[i] <= 50
1 <= target <= 30

class Solution:
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        """
        解题思路：dfs深搜，枚举每个位置，拿或者不拿
        时间复杂度：O(2^n)
        """
        result = []
        # 集合去重
        used = set()
        sums = [0] * len(candidates)

        def dfs(index: int, cur_num: int, cur_list: List[int]):
            if cur_num == target:
                l = sorted(list(cur_list))
                use_key = tuple(l)
                if used.__contains__(use_key):
                    return
                used.add(use_key)
                result.append(l)
                return
            if cur_num > target:
                return
            if index >= 0 and sums[-1] - sums[index] < target - cur_num:
                # 剪枝，剩余的不够
                return
            for j in range(index + 1, len(candidates)):
                cur_list.append(candidates[j])
                dfs(j, cur_num + candidates[j], cur_list)
                cur_list.pop(len(cur_list) - 1)

        # 预处理前n个和
        sums[0] = candidates[0]
        for i in range(1, len(candidates)):
            sums[i] = sums[i - 1] + candidates[i]

        dfs(-1, 0, [])
        return result

学习别人更好的解法：

Loading...Level up your coding skills and quickly land a job. This is the best place to expand your knowledge and get prepared for your next interview.https://leetcode.com/problems/combination-sum-ii/discuss/16944/Beating-98-Python-solution-using-recursion-with-comments

class Solution:
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        # Sorting is really helpful, se we can avoid over counting easily
        candidates.sort()                      
        result = []
        self.combine_sum_2(candidates, 0, [], result, target)
        return result
    
    def combine_sum_2(self, nums, start, path, result, target):
        # Base case: if the sum of the path satisfies the target, we will consider 
        # it as a solution, and stop there
        if not target:
            result.append(path)
            return
    
        for i in range(start, len(nums)):
            # Very important here! We don't use `i > 0` because we always want 
            # to count the first element in this recursive step even if it is the same 
            # as one before. To avoid overcounting, we just ignore the duplicates
            # after the first element.
            if i > start and nums[i] == nums[i - 1]:
                continue

            # If the current element is bigger than the assigned target, there is 
            # no need to keep searching, since all the numbers are positive
            if nums[i] > target:
                break

            # We change the start to `i + 1` because one element only could
            # be used once
            self.combine_sum_2(nums, i + 1, path + [nums[i]], result, target - nums[i])