组合总和算法-CSDN博客

39. 组合总和

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

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

说明：

所有数字（包括 target）都是正整数。
解集不能包含重复的组合。
示例 1：

输入：candidates = [2,3,6,7], target = 7,
所求解集为：
[
  [7],
  [2,2,3]
]

示例 2：

输入：candidates = [2,3,5], target = 8,
所求解集为：
[
  [2,2,2,2],
  [2,3,3],
  [3,5]
]

提示：

1 <= candidates.length <= 30
1 <= candidates[i] <= 200
candidate 中的每个元素都是独一无二的。
1 <= target <= 500

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

public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> list = new ArrayList<>();
        if (candidates.length == 0) {
            return list;
        }
        Deque<Integer> stack = new ArrayDeque<>();

        dfs(candidates, target, stack, list, 0);
        return list;
    }

    /**
     * @param candidates 深度遍历的数组
     * @param target 不断变换的目标值比如 7 - 2 == 5；  5 - 2 == 3； 3 - 2 == 1； 1 - 2 == -1
     * @param stack 存储的数据结构栈 比如保存 2 2 2 2;
     * @param begin 避免重复 所以下一轮深度遍历的不能用上一轮已经遍历过的candidates[i] 也就是每次遍历开始的点。
     */
    private void dfs(int[] candidates, int target, Deque<Integer> stack, List<List<Integer>> list, int begin){
        //证明这个栈的数相加起来大于7
        if (target < 0){
            return;
        }

        if (target == 0){
//            List<Integer> subList = new ArrayList<>();
//            ArrayList<Integer> subList = new ArrayList<>(stack);
            list.add(new ArrayList<>(stack));
            return;
        }

        //i 不能是0 不然会重复的
        for (int i = begin; i < candidates.length; i++) {
            stack.addLast(candidates[i]);

            //每个数都要从自己本身开始遍历 跟我举得例子类似 所以begin还是i
            dfs(candidates, target - candidates[i], stack, list, i);

            //没找到 就把刚刚加到栈里的数拿出来 比如
            //7 - 2 == 5；  5 - 2 == 3； 3 - 2 == 1； 1 - 2 == -1 把-2拿出来。
            stack.removeLast();
        }
    }

//优化
public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> list = new ArrayList<>();
        if (candidates.length == 0) {
            return list;
        }
        Deque<Integer> stack = new ArrayDeque<>();
        //减少遍历的情况 前提要数组是有序的
        Arrays.sort(candidates);
        dfs(candidates, target, stack, list, 0);
        return list;
    }

    /**
     * @param candidates 深度遍历的数组
     * @param target 不断变换的目标值比如 7 - 2 == 5；  5 - 2 == 3； 3 - 2 == 1； 1 - 2 == -1
     * @param stack 存储的数据结构栈 比如保存 2 2 2 2;
     * @param begin 避免重复 所以下一轮深度遍历的不能用上一轮已经遍历过的candidates[i] 也就是每次遍历开始的点。
     */
    private void dfs(int[] candidates, int target, Deque<Integer> stack, List<List<Integer>> list, int begin){
        //证明这个栈的数相加起来大于7
        /*if (target < 0){
            return;
        }*/

        if (target == 0){
//            List<Integer> subList = new ArrayList<>();
//            ArrayList<Integer> subList = new ArrayList<>(stack);
            list.add(new ArrayList<>(stack));
            return;
        }

        //i 不能是0 不然会重复的
        for (int i = begin; i < candidates.length; i++) {
            /*
            * 7 - 2 == 5；  5 - 2 == 3； 3 - 2 == 1； 1 - 2 == -1已经发现小于0了
            * 就不用了再遍历 1 - 3； 1 - 6； 1 - 7；了 所以每次遍历之前看看情况
            * */
            if (target - candidates[i] < 0){
                break;
            }

            stack.addLast(candidates[i]);

            //每个数都要从自己本身开始遍历 跟我举得例子类似 所以begin还是i
            dfs(candidates, target - candidates[i], stack, list, i);

            //没找到 就把刚刚加到栈里的数拿出来 比如
            //7 - 2 == 5；  5 - 2 == 3； 3 - 2 == 1； 1 - 2 == -1 把-2拿出来。
            stack.removeLast();
        }
    }