Combination Sum

最新推荐文章于 2025-05-25 18:32:47 发布

violet_program

最新推荐文章于 2025-05-25 18:32:47 发布

阅读量526

点赞数

CC 4.0 BY-SA版权

分类专栏： Recursive

本文链接：https://blog.youkuaiyun.com/violet_program/article/details/8967992

Recursive 专栏收录该内容

30 篇文章

订阅专栏

本文提供了一种使用深度优先搜索（DFS）和动态规划（DP）方法来解决给定候选数集合中寻找所有组合，使得这些组合的元素之和等于特定目标数的问题。详细介绍了两种算法实现过程，包括排序、回溯搜索和状态转移方程，并通过实例展示了解决方案的应用。

摘要生成于 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 (a₁, a₂, � , a_k) must be in non-descending order. (ie, a₁ ? a₂ ? � ? a_k).
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]

DFS solution:

public class Solution {
    public ArrayList<Integer> cur;
	public ArrayList<ArrayList<Integer>> res;
	public ArrayList<ArrayList<Integer>> combinationSum(int[] candidates,
			int target) {
		// Start typing your Java solution below
		// DO NOT write main() function
		res = new ArrayList<ArrayList<Integer>>();
		cur = new ArrayList<Integer>();
		Arrays.sort(candidates);
		find(candidates, 0, cur, target);
		return res;
	}
	public void find(int[] candidates, int index, ArrayList<Integer> cur, int target){
		if(target == 0)
			res.add(new ArrayList<Integer>(cur));
		else{
			for(int i = index; i < candidates.length; i++){
				if(target >= candidates[i]){
					cur.add(candidates[i]);
					find(candidates, i, cur, target - candidates[i]);
					cur.remove(cur.size() - 1);
				}
			}
		}
	}
}

DP solution: sum(target) = {sum(target-a[i]), a[i]}

import java.util.Hashtable;
public class Solution {
    public ArrayList<ArrayList<Integer>> combinationSum(int[] candidates,
			int target) {
		// Start typing your Java solution below
		// DO NOT write main() function
		Arrays.sort(candidates);
		Hashtable<Integer, ArrayList<ArrayList<Integer>>> sum = new Hashtable<Integer, ArrayList<ArrayList<Integer>>>();
		for(int i = 1; i <= target; i++){
			sum.put(i, new ArrayList<ArrayList<Integer>>());
			int size = candidates.length;
			for(int j = 0; j < size; j++){
				if(i < candidates[j])
					continue;
				else if(i == candidates[j]){
					ArrayList<Integer> x = new ArrayList<Integer>();
					x.add(i);
					sum.get(i).add(x);
					continue;
				}
				else{
					int temp = i - candidates[j];
					for(int k = 0; k < sum.get(temp).size(); k++){
						ArrayList<Integer> res = new ArrayList<Integer>(sum.get(temp).get(k));
						if(res.get(res.size() - 1) <= candidates[j]){
							res.add(candidates[j]);
							sum.get(i).add(res);
						}
					}
				}
			}
		}
		return sum.get(target);
	}
}