【Day 80 】2023-08-28 - 39 组合总和

[azl397985856]

39 组合总和

入选理由

暂无

题目地址

https://leetcode-cn.com/problems/combination-sum/

前置知识

• 剪枝
• 回溯

  题目描述

  
  给定一个无重复元素的数组 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] ]

提示：

1 <= candidates.length <= 30 1 <= candidates[i] <= 200 candidate 中的每个元素都是独一无二的。 1 <= target <= 500

[Beanza]

*/ class Solution { public TreeNode pruneTree(TreeNode root) { if(root == null){ return null; } root.left = pruneTree(root.left); root.right = pruneTree(root.right); if(root.left == null && root.right == null && root.val == 0){ return null; } return root; } }

[GuitarYs]

class Solution:
    def combinationSum(self, candidates, target):
        result = []
        candidates.sort()
        def backtrack(start, curr_list, curr_sum):
            if curr_sum == target:
                result.append(curr_list[:])
                return
            if curr_sum > target:
                return
            for i in range(start, len(candidates)):
                curr_list.append(candidates[i]) 
                curr_sum += candidates[i] 
                backtrack(i, curr_list, curr_sum)
                curr_list.pop()  
                curr_sum -= candidates[i]  
        backtrack(0, [], 0)

        return result

[freesan44]

class Solution {
    func combinationSum(_ candidates: [Int], _ target: Int) -> [[Int]] {
        var ans = [[Int]]()

        func backtrack(_ list: inout [[Int]], _ tempList: inout [Int], _ nums: [Int], _ remain: Int, _ start: Int) {
            if remain < 0 {
                return
            } else if remain == 0 {
                list.append(tempList)
                return
            }
            for i in start..<nums.count {
                tempList.append(nums[i])
                backtrack(&list, &tempList, nums, remain - nums[i], i)
                tempList.removeLast()
            }
        }

        var tempList = [Int]()
        backtrack(&ans, &tempList, candidates.sorted(), target, 0)
        return ans
    }
}

[Diana21170648]

思路

回溯 剪枝

代码

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        def backtrack(ans,temp,candidates,tar,start):
            if tar<0:
                return
            elif tar==0:
                return ans.append(temp.copy())
            for i in range(start,len(candidates)):
                temp.append(candidates[i])
                backtrack(ans,temp,candidates,tar-candidates[i],i)#代表数字可以重复使用
                temp.pop()
        ans=[]
        backtrack(ans,[],candidates,target,0)
        return ans

复杂度分析

• 时间复杂度：O(N^H)，其中 N 为数组长度,H为递归栈的最大深度。
• 空间复杂度：O(H)，H为递归栈的最大深度.

[passengersa]

代码： /**

• @param {number[]} candidates
• @param {number} target

• @return {number[][]} */ var combinationSum = function(candidates, target) { candidates.sort((a,b) => a-b); // 先对数组进行排序，方便剪枝 let combination = []; let path = []; const len = candidates.length, minNum = candidates[0]; getCombination(candidates, target, 0, path); // 递归函数

  function getCombination(candidates, target, start, path){ if(target == 0) return combination.push(path.slice()); // 找到组合，返回到解集之中 if(target < minNum) return; for(let i = start; i < len; i++){ path.push(candidates[i]); // 对 i节点进行递归，注意 target要减少噢 getCombination(candidates, target-candidates[i], i, path); path.pop(); } } return combination;

};

[Fuku-L]

代码

class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> ans = new ArrayList<List<Integer>>();
        List<Integer> combine = new ArrayList<Integer>();
        dfs(candidates, target, ans, combine, 0);
        return ans;
    }
    private void dfs(int[] candidates, int target, List<List<Integer>> ans, List<Integer> combine, int idx){
        if(idx == candidates.length){
            return;
        }
        if(target == 0){
            ans.add(new ArrayList<Integer>(combine));
            return;
        }
        // 跳过
        dfs(candidates, target, ans, combine, idx+1);
        // 选择当前数
        if(target - candidates[idx] >= 0){
            combine.add(candidates[idx]);
            dfs(candidates, target - candidates[idx], ans, combine, idx);
            combine.remove(combine.size() - 1);
        }
    }
}

[Alexno1no2]

from typing import List

class Solution:
    def __init__(self):
        self.res = []
        # 记录回溯的路径
        self.track = []
        # 记录 track 中的路径和
        self.trackSum = 0

    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        if len(candidates) == 0:
            return self.res
        self.backtrack(candidates, 0, target)
        return self.res

    # 回溯算法主函数
    def backtrack(self, nums: List[int], start: int, target: int) -> None:
        # base case，找到目标和，记录结果
        if self.trackSum == target:
            self.res.append(list(self.track))
            return None
        # base case，超过目标和，停止向下遍历
        if self.trackSum > target:
            return None

        # 回溯算法标准框架
        for i in range(start, len(nums)):
            # 选择 nums[i]
            self.trackSum += nums[i]
            self.track.append(nums[i])
            # 递归遍历下一层回溯树
            # 同一元素可重复使用，注意参数
            self.backtrack(nums, i, target)
            # 撤销选择 nums[i]
            self.trackSum -= nums[i]
            self.track.pop()