<leetcode> Combination Sum-优快云博客

本文链接：https://blog.youkuaiyun.com/gawain_rutgers/article/details/39336633

本文介绍了一种寻找候选数集合中所有唯一组合的算法，这些组合的和等于目标数。算法采用深度优先搜索加递归的方式实现，允许候选数重复使用。文章详细解释了排序、递归搜索和组合添加的过程。

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

Given a set of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.

The same repeated number may be chosen from C unlimited number of times.

Note:

All numbers (including target) will be positive integers.
Elements in a combination (a1, a2, … , ak) must be in non-descending order. (ie, a1 ≤ a2 ≤ … ≤ ak).
The solution set must not contain duplicate combinations.

For example, given candidate set 2,3,6,7 and target 7,
A solution set is:
[7]

[2, 2, 3]

算法：同Combinations, DFS+recusion

首先对数组排序(题目要求升序输出)。

然后DFS+recusion进行枚举，题目要求每个元素可以使用多次，所以level指向当前的level而不是下一层，并在recusion中添加参数target，为当前的target-candidates[i](省去list求和过程)。返回条件是target＝＝0，添加当前list到result，或者target<0，当前组合不是solution，返回。

同Combination, 每次recusion传递前需要克隆一个list

public class Solution {
    	public int[] copy;
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> result=new ArrayList<List<Integer>>();
        ArrayList<Integer> solution=new ArrayList<Integer>();
        if(candidates.length<=0){
            return result;
        }
        else{
        	copy=new int[candidates.length];
        	 mergeSort(candidates,0,candidates.length-1);
            findCombination(candidates,target,0,result,solution);
        }
        return result;
    }
    public void findCombination(int[] candidates, int target, int level, List<List<Integer>> result, ArrayList<Integer> solution){
        if(target==0){
            result.add(solution);
            return;
        }
        if(target<0){
            return;
        }
        for(int i=level;i<candidates.length;i++){
            ArrayList<Integer> solutionCopy=(ArrayList)solution.clone();//Clone list
            solutionCopy.add(candidates[i]);
            findCombination(candidates,target-candidates[i],i,result,solutionCopy);//level is current i(level)
        }
    }
    /*
    * Merge sort
    */
    public void mergeArray(int[] numbers,int low,int mid,int high){
        int k=low,l=mid+1;
        for(int i=low;i<=high;i++){
            copy[i]=numbers[i];
        }
        for(int j=low;j<=high;j++){
            if(k>mid){
                numbers[j]=copy[l];
                l++;
            }
            else if(l>high){
                numbers[j]=copy[k];
                k++;
            }
            else if(copy[k]<copy[l]){
                numbers[j]=copy[k];
                k++;
            }
            else if(copy[k]>=copy[l]){
                numbers[j]=copy[l];
                l++;
            }
        }
    }
    public void mergeSort(int[] numbers,int low,int high){
        if(high<=low){
            return;
        }
        int mid=(low+high)/2;
        mergeSort(numbers,low,mid);
        mergeSort(numbers,mid+1,high);
        mergeArray(numbers,low,mid,high);
    }

}