回溯算法——77，216

今天学习回溯算法，回溯伴随着递归。而回溯算法的本质，就是通过递归来遍历出该问题的所有情况，在这所有情况里，寻找符合题意的解。所以，回溯并不是什么高深的算法，本质就是遍历，它的效率并不高。如此一来，就引出了回溯。如果一道题中，用到了递归进行遍历所有可能的情况，那么就很有可能出现回溯。简单来说，回溯就是，在递归时，发现该种情况不符合要求，要回退到先前的某一步，回退的过程即是回溯。

回溯算法也有固定的解题模板，按照模板，我们可以很快建立出大致思路。

	void backtracking(参数) {
	    if (终止条件) {
	        存放结果;
	        return;
	    }
	    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
	        处理节点;
	        backtracking(路径，选择列表); // 递归
	        回溯，撤销处理结果
	    }
	}

LeetCode77.组合

这道题的题目非常简短，题意也很清楚，就是寻找出不同的组合。看到这道题的第一反应，应该都是使用多层for循环进行遍历，尤其它的示例给了一些先入为主的印象，好像和以前做过的两层for循环一样，暴力搜索就可以了。这当然是没错的，这个示例也可以用两层循环暴力搜索出来。但是，如果这里的k并不等于2呢，如果等于3，4，5……，那就需要对应的3层，4层，5层循环进行暴力搜索。再但是，这里的k并不是固定的，以前的题目种，我们在编写代码时，一般就已经确定了需要几层循环，比如我们写了一个两层循环的方法，而传入的参数k的值确实3，应该怎么办呢？所以，这里就需要用到递归，来模拟动态的多层循环暴力破解。

那么我们就能大概想到，本题的大致思路，以示例1为例：先加入1，然后再加入2，之后将2弹出，再加入3，……。不断进行以上操作，即可遍历出所有结果。而这其中，将x弹出，就是本题的回溯部分，我们需要回退至少一个值的状态，接收新的值来组成新的组合，如果没有这步回溯操作，就会变成：先加入1，然后再加入2，再加入3，……。最后的结果会是：1234……，明显不符合题意。

public class Combine77 {

    List<Integer> path=new ArrayList<>();
    List<List<Integer>> result=new ArrayList<>();
    
    void backtracking(int n, int k, int startIndex){
        if (path.size()==k){
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = startIndex; i <= n ; i++) {
            path.add(i);
            backtracking(n,k,i+1);             //从这里调用递归，执行完成全部语句，或者遇到return，还是从这里出来
            path.removeLast();                          //每次循环是叶子结点上面的，叶子结点遍历完后，还需要再次弹出一次，也就是回溯
        }                                               //回溯到上一层节点，下一个节点继续遍历其叶子节点
    }
    
    public List<List<Integer>> combine(int n,int k){
        backtracking(n,k,1);
        return result;
    }
}

path是每次遍历的结果，当path符合题目要求时，也就是path的长度等于k时，将path再存入result。而每次调用backtracking，就是一次递归的过程，为什么还要在外面套一个循环，这是因为，递归相当于对树形结构进行纵向遍历，而for循环则是对其进行横向遍历。比如当添加一个1后，1后面可以跟2，也可跟3，这就是循环的意义。最后，从递归函数出来后，进行回溯操作，即将最后一个元素弹出，等待添加下一个元素。

这里需要注意的是，每一层递归函数中，都有for循环，所以，每一层递归函数的i并不相同。

LeetCode216.组合总和Ⅲ

本题思路和上一道题几乎一样，只不过需要两层判断，一个是和等于n，一个是数组长度等于k。

public class CombinationSum3216 {
    List<List<Integer>> result=new ArrayList<>();
    List<Integer> path=new ArrayList<>();

    public void backtracking(int k, int n, int startIndex){
        if (path.size()==k){
            int sum=0;
            for (int i = 0; i < path.size(); i++) {
                sum=sum+ path.get(i);
            }
            if (sum==n){
                result.add(new ArrayList<>(path));
            }
            return;
        }
        for (int i = startIndex; i <= 9; i++) {
            path.add(i);
            backtracking(k,n,i+1);
            path.removeLast();
        }
    }
    
    public List<List<Integer>> combinationSum3(int k, int n){
        backtracking(k,n,1);
        return result;
    }
}