LeetCode T39 Combination Sum

题目地址

中文：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);
    }
}