【Leetcode】Combination Sum I

最新推荐文章于 2025-08-13 21:50:19 发布

yyz20002008

最新推荐文章于 2025-08-13 21:50:19 发布

阅读量98

点赞数

文章标签： leetcode java arraylist List

本文介绍了一个算法问题，即给定一组候选整数和一个目标整数，找到所有可能的候选数组合，这些组合的和等于目标数。允许重复选择候选数，且组合需按升序排列，避免重复解集。

摘要生成于 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]

Java:

模仿版：

public class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        if(candidates.length==0) return null;
        List<List<Integer>> res= new ArrayList<List<Integer>>();
        ArrayList<Integer> item= new ArrayList<Integer>();
         Arrays.sort(candidates);
        int start=0;
        help(candidates,target,item,res,start);
        return res;
        
    }
    public void help(int[] can, int target,ArrayList<Integer> item, List<List<Integer>> res, int start){
        if(target<0)
        {
         return;
        }
        if(target==0)
        {
            res.add(new ArrayList<Integer> (item));
        }
        else{
            for(int i=start;i<can.length;i++)
            {
                if(i>0 && can[i]==can[i-1])  //这道题其实没有这句也能过，因为好像题目不会给有重复元素的集合
                continue;
                item.add(can[i]);
                help(can, target-can[i],item,res,i);
                item.remove(item.size()-1);
                
            }
        }
    }
}

1. 征服大神：http://blog.youkuaiyun.com/linhuanmars/article/details/20828631

public ArrayList<ArrayList<Integer>> combinationSum(int[] candidates, int target) {  
    ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();  
    if(candidates == null || candidates.length==0)  
        return res;  
    Arrays.sort(candidates);  
    helper(candidates,0,target,new ArrayList<Integer>(),res);  
    return res;  
}  
private void helper(int[] candidates, int start, int target, ArrayList<Integer> item,   
ArrayList<ArrayList<Integer>> res)  
{  
    if(target<0)  
        return;  
    if(target==0)  
    {  
        res.add(new ArrayList<Integer>(item));  
        return;  
    }  
    for(int i=start;i<candidates.length;i++)  
    {  
        if(i>0 && candidates[i]==candidates[i-1])  
            continue;  
        item.add(candidates[i]);  
        helper(candidates,i,target-candidates[i],item,res);  
        item.remove(item.size()-1);  
    }  
}

2.http://blog.youkuaiyun.com/yiding_he/article/details/18893515

public class Solution {  
    public ArrayList<ArrayList<Integer>> combinationSum(int[] candidates,  
            int target) {  
        ArrayList<ArrayList<Integer>> results = new ArrayList<ArrayList<Integer>>();  
        if (candidates.length == 0) {  
            return results;  
        }  
        Arrays.sort(candidates);  
        ArrayList<Integer> result = new ArrayList<Integer>();  
        dfs(results, candidates, target, result, 0, 0);  
        return results;  
    }  
  
    private void dfs(ArrayList<ArrayList<Integer>> results, int[] candidates,  
            int target, ArrayList<Integer> result, int step, int sum) {  
        if (sum == target) {  
            if (!results.contains(result)) {  
                results.add(new ArrayList<Integer>(result));  
            }  
            return;  
        }  
        if (sum > target) {  
            return;  
        }  
        for (int i = step; i < candidates.length; i++) {  
            result.add(candidates[i]);  
            dfs(results, candidates, target, result, i, sum + candidates[i]);  
            result.remove(result.size() - 1);  
        }  
        return;  
    }  
}