深度优先遍历
对于深度优先遍历dfs，我们可以使用递归+回溯进行实现；预先定义一个栈或者队列都行，然后将每次满足的结果加入到集合当中，然后进行递归，再将集合尾部的元素删除进行回溯。
组合总和问题使用深度优先遍历实现代码如下：

//定义方法用来实现深度优先遍历
    public void dfs(int[] candidates,int start,int len,int target,Deque<Integer> que,List<List<Integer>> list){
        if(target==0){
            list.add(new ArrayList(que));
            return;
        }
        //
        for(int i=start;i<len;i++){
            //进行剪枝
            if(target-candidates[i]<0){
                break;
            }
            //执行到这里说明减去一个candidates当中的元素后target仍然大于0
            //将当前元素加入到可能的结果队列当中
            que.addLast(candidates[i]);
            //深度优先遍历
            dfs(candidates,i,len,target-candidates[i],que,list);
            //回溯
            que.removeLast();
        }
    }

使用深度优先遍历解决组合总和问题：
题目概述：
给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

示例：

输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

ps:
这里实现问题的两大难点：
（1）如何解决满足条件的重复元素
（2）如何简化操作实行剪枝

（1）避免重复元素：
在结果当中满足条件的组合如[2,2,3]、[3,2,2]、[2,3,2]等其实属于同一个结果，需要将重复的结果进行删除

for(int i=start;i<len;i++)
....................................
。。。。。。。。。。。。。。。。。。。。。
//深度优先遍历
dfs(candidates,i,len,target-candidates[i],que,list);

上述在for循环中的i初始时，我们递归传递的参数是start，这样就能在回溯下一个枝杈时，使得i++，这样能够不再重复使用上一次使用的元素。

（2）将数组先进行排序，然后再依次遍历删掉target-当前元素<0的值，即可进行剪枝。

算法实现：
（关键思路：构造一棵树，依次进行target-candidates[i]）

class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        //定义一个列表用来存储结果
        List<List<Integer>> list = new ArrayList<>();
        //双向队列
        Deque<Integer> que = new ArrayDeque<>();
        if(candidates==null){
            return list;
        }
        //先将数组进行排序为了进行剪枝
        Arrays.sort(candidates);
        dfs(candidates,0,candidates.length,target,que,list);
        return list;
        
    }
    //定义方法用来实现深度优先遍历
    public void dfs(int[] candidates,int start,int len,int target,Deque<Integer> que,List<List<Integer>> list){
        if(target==0){
            list.add(new ArrayList(que));
            return;
        }
        //
        for(int i=start;i<len;i++){
            //进行剪枝
            if(target-candidates[i]<0){
                break;
            }
            //执行到这里说明减去一个candidates当中的元素后target仍然大于0
            //将当前元素加入到可能的结果队列当中
            que.addLast(candidates[i]);
            //深度优先遍历
            dfs(candidates,i,len,target-candidates[i],que,list);
            //回溯
            que.removeLast();
        }
    }
}