leetcode算法整理39组合总和

LEETCODE算法注解39：

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 
中所有可以使数字和为 target 的组合。

candidates 中的数字可以无限制重复被选取。

说明：

    所有数字（包括 target）都是正整数。
    解集不能包含重复的组合
    
输入: candidates = [2,3,6,7], target = 7,
所求解集为:
[
  [7],
  [2,2,3]
]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/combination-sum

此题所得：回溯是一种思想，递归是一种方法。
思路：既然要求不能重复，那每一次组合的值都必须大于等于上一次组合的值，因此这就要求我们数组首先排序。

第一次2添加 ，第二次添加的值必须大于等于2

下图为回溯的思路

一句话总结：不断选择数字，每一次选择的数字要大于等于上一次选择的，最后直到target等于0时说明出现了一组结果。当发现剩余的target已经小于candidates中的最小值时，不用继续增加，直接回溯到上一层。

class Solution {
   List<List<Integer>> lists = new ArrayList<>();

	    public List<List<Integer>> combinationSum(int[] candidates, int target) {
	        if (candidates == null || candidates.length == 0 || target < 0) {
	            return lists;
	        }
	        Arrays.sort(candidates);
	        List<Integer> list = new ArrayList<>();
	        process(0, candidates, target, list, 0);
	        return lists;
	    }
      //三个输出语句被注释了，想要看具体运行结果可以打印这三句话看看。
	    private void process(int start, int[] candidates, int target, List<Integer> list, int lastval) {
	        //递归的终止条件
	        if (target == 0) {
	        //System.out.println("有结果输出");
	            lists.add(new ArrayList<>(list));
	        } //已经不够减了，直接返回
            else if(target < candidates[0]){
                return ;
            }
            else {
	            for (int i = start; i < candidates.length; i++) {
	            //
	            	if(candidates[lastval] <= candidates[i])
	            	{
	                list.add(candidates[i]);
	                //System.out.println("添加值"+candidates[i]);
	                process(0, candidates, target - candidates[i], list, i);
	                //System.out.println("移除值"+list.get(list.size() - 1));
	                list.remove(list.size() - 1);
	            	}
	                
	            }
	        }

	    }
}

我有突然想到，既然我数组已经排序了，我为什么还要做比较。去掉if判断
candidates[i]必然小于candidates[i+1]
for (int i = start; i < candidates.length; i++) {
	            //	
	            /*
	            	if(candidates[lastval] <= candidates[i])
	            	{
	                list.add(candidates[i]);
	                //System.out.println("添加值"+candidates[i]);
	                process(0, candidates, target - candidates[i], list, i);
	                //System.out.println("移除值"+list.get(list.size() - 1));
	                list.remove(list.size() - 1);
	            	}
	              */  
	              	list.add(candidates[i]);
	              	//此处的初始值变为了i，我们方法都可以修改了，第五个变量lastval可以去掉了，根本不需要，因为我们选择的数组必然大于等于lastval
	                process(i, candidates, target - candidates[i], list);
	                list.remove(list.size() - 1);
	            }

下面给出大佬的代码。思路相近，也可以参考一下。
List<List<Integer>> lists = new ArrayList<>();

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        if (candidates == null || candidates.length == 0 || target < 0) {
            return lists;
        }

        List<Integer> list = new ArrayList<>();
        process(0, candidates, target, list);
        return lists;
    }

    private void process(int start, int[] candidates, int target, List<Integer> list) {
        //递归的终止条件
        if (target < 0) {
            return;
        }
        if (target == 0) {
            lists.add(new ArrayList<>(list));
        } else {
            for (int i = start; i < candidates.length; i++) {
                list.add(candidates[i]);
                //因为每个数字都可以使用无数次，所以递归还可以从当前元素开始
                process(i, candidates, target - candidates[i], list);
                list.remove(list.size() - 1);
            }
        }

    }

作者：reedfan
链接：https://leetcode-cn.com/problems/combination-sum/solution/fei-chang-xiang-xi-de-di-gui-hui-su-tao-lu-by-reed/
来源：力扣（LeetCode）
侵权联系删除