77.组合 （回溯法经典问题）

把问题抽象成树问题。
要注意的两个点：

1. 在下次选取过程中不能重复。即 不能有2，2 3，3 等一个数出现多次（start从i+1开始的原因）
2. 每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围，就是要靠start。 如果没有start 结果会有重复的。 这里的重复指的是4，2 2，4这样的重复。

可以自己先一步一步的尝试。

比如 下面是start不从i+1开始的代码

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> combine(int n, int k) {
        dfs(n,k,new ArrayList<>(),1);
        return res;
    }

    public void dfs(int n,int k,List<Integer> path,int start){
        if(path.size() == k){
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i = start;i <=n ;i++){
            path.add(i);
            dfs(n,k,path,i);
            path.remove(path.size() - 1);
        }
    }
}

明显有2，2 1，1 这种组合 是不合理的。

下面是没有考虑从start开始的代码

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> combine(int n, int k) {
        dfs(n,k,new ArrayList<>());
        return res;
    }

    public void dfs(int n,int k,List<Integer> path){
        if(path.size() == k){
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i = 1;i <=n ;i++){
            path.add(i);
            dfs(n,k,path);
            path.remove(path.size() - 1);
        }
    }
}

很明显，他还比上面的结果多包含了像3，4 4，3这样的重复元组。

i从start开始的目的从每一层的第 2 个结点开始，都不能再搜索产生同一层结点已经使用过的 candidate 里的元素。

正确代码

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> combine(int n, int k) {
        dfs(n,k,new ArrayList<>(),1);
        return res;
    }

    public void dfs(int n,int k,List<Integer> path,int start){
        if(path.size() == k){
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i = start;i <=n ;i++){
            path.add(i);
            dfs(n,k,path,i+1);
            path.remove(path.size() - 1);
        }
    }
}

剪枝优化

来举一个例子，n = 4，k = 4的话，那么第一层for循环的时候，从元素2开始的遍历都没有意义了。 在第二层for循环，从元素3开始的遍历都没有意义了。

这么说有点抽象，如图所示：


图中每一个节点（图中为矩形），就代表本层的一个for循环，那么每一层的for循环从第二个数开始遍历的话，都没有意义，都是无效遍历。

所以，可以剪枝的地方就在递归中每一层的for循环所选择的起始位置。
如果for循环选择的起始位置之后的元素个数 已经不足 我们需要的元素个数了，那么就没有必要搜索了。
注意代码中i，就是for循环里选择的起始位置。

接下来看一下优化过程如下：

已经选择的元素个数：path.size();

还需要的元素个数为: k - path.size();

在集合n中至多要从该起始位置 : n - (k - path.size()) + 1，开始遍历

为什么有个+1呢，因为包括起始位置，我们要是一个左闭的集合。

举个例子，n = 4，k = 3， 目前已经选取的元素为0（path.size为0），n - (k - 0) + 1 即 4 - ( 3 - 0) + 1 = 2。

从2开始搜索都是合理的，可以是组合[2, 3, 4]。

这里大家想不懂的话，建议也举一个例子，就知道是不是要+1了。

所以优化之后的for循环是：

for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) // i为本次搜索的起始位置

（注意索引是从1开始的不是从0开始的）