LeetCode T39 Combination Sum-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_31650113/article/details/112613283

该博客探讨了如何利用回溯算法解决LeetCode上的组合求和问题。给定一组不重复的整数和一个目标值，目标是找出所有可能的组合，使得组合中的数字之和等于目标值。博客通过一个具体的示例解释了递归和回溯的概念，并提供了Java代码实现。此问题的关键在于理解递归策略和处理重复选择的可能性。

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

文章目录

题目地址
题目描述
思路
题解

题目地址

中文：https://leetcode-cn.com/problems/combination-sum/
英文：https://leetcode.com/problems/combination-sum/

题目描述

Given an array of distinct integers candidates and a target integer target, return a list of all unique combinations of candidates where the chosen numbers sum to target. You may return the combinations in any order.

The same number may be chosen from candidates an unlimited number of times. Two combinations are unique if the frequency of at least one of the chosen numbers is different.

It is guaranteed that the number of unique combinations that sum up to target is less than 150 combinations for the given input.

Example 1:

Input: candidates = [2,3,6,7], target = 7
Output: [[2,2,3],[7]]
Explanation:
2 and 3 are candidates, and 2 + 2 + 3 = 7. Note that 2 can be used multiple times.
7 is a candidate, and 7 = 7.
These are the only two combinations.

Example 2:

Input: candidates = [2,3,5], target = 8
Output: [[2,2,2,2],[2,3,3],[3,5]]

Example 3:

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

Example 4:

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

Example 5:

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

Constraints:

1 <= candidates.length <= 30
1 <= candidates[i] <= 200
All elements of candidates are distinct.
1 <= target <= 500

思路

跟38题一样，是递归-回溯的思路，既然每个数字能重复使用多次，那么我们就使用一个递归f(x)，不断调用f(x)和f(x+1)，x的意思是备选数组的下标，f(x)的意思是使用下标为x的数，f(x+1)的意思就是跳过x，使用x+1位置的数。
递归的深度最差在target，当数组有元素的值为1时。
时间复杂度

题解

class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> lists = new ArrayList<>();
        List<Integer> list = new ArrayList<Integer>();

        findCombination(candidates,target,lists,list,0);
        
        return lists;
    }

    public void findCombination(int[] candidates,int target,List<List<Integer>> lists,List<Integer> list,int index){
        if(target<=0){
            if(target==0)
                lists.add(new ArrayList<Integer>(list));
            return;
        }
        if(index==candidates.length) return;
        target -= candidates[index];
        list.add(candidates[index]);
        findCombination(candidates,target,lists,list,index);
        target += candidates[index];
        list.remove(list.size()-1);
        findCombination(candidates,target,lists,list,index+1);
    }
}