“持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第5天，点击查看活动详情”

前言

之前小六六一直觉得自己的算法比较菜，算是一个短板吧，以前刷题也还真是三天打鱼，两台晒网，刷几天，然后就慢慢的不坚持了，所以这次，借助平台的活动，打算慢慢的开始开刷，并且自己还会给刷的题总结下，谈谈自己的一些思考，和自己的思路等等，希望对小伙伴能有所帮助吧，也可以借此机会把自己短板补一补，希望自己能坚持下去呀

题目

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

输入： n = 4, k = 2
输出：
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]
复制代码

题目分析

其实这题有点像我们数学学的一个知识点，排列组合，穷举类似。但是这个题虽然是思路是穷举，但是你不可能用for循环去解答出来的。因为不n的大小不确认，如果假设n=4，k=2的话的话，其实你可以这样

int n = 4;
for (int i = 1; i <= n; i++) {
    for (int j = i + 1; j <= n; j++) {
        for (int u = j + 1; u <= n; n++) {
           for (int f = j + 1; f <= n; f++) {
            }
        }
    }
}
复制代码

但是很不幸，我们不能把它当成一个通用的写法，因为当n和k很大的时候，你估计想死的心都有了，所以用回溯

什么是回溯算法，一看就会，一写就废

那其实这题的解法就是回溯法，那什么是回溯呢？

回溯法（探索与回溯法）是一种选优搜索法，又称为试探法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯[条件]的某个[状态]的点称为“回溯点”。

在回溯法中，每次扩大当前部分解时，都面临一个可选的状态集合，新的部分解就通过在该集合中选择构造而成。这样的状态集合，其结构是一棵多叉树，每个树结点代表一个可能的部分解，它的儿子是在它的基础上生成的其他部分解。树根为初始状态，这样的状态集合称为状态空间树。

回溯法对任一解的生成，一般都采用逐步扩大解的方式。每前进一步，都试图在当前部分解的基础上扩大该部分解。它在问题的状态空间树中，从开始结点（根结点）出发，以深度优先搜索整个状态空间。这个开始结点成为活结点，同时也成为当前的扩展结点。在当前扩展结点处，搜索向纵深方向移至一个新结点。这个新结点成为新的活结点，并成为当前扩展结点。如果在当前扩展结点处不能再向纵深方向移动，则当前扩展结点就成为死结点。此时，应往回移动（回溯）至最近的活结点处，并使这个活结点成为当前扩展结点。回溯法以这种工作方式递归地在状态空间中搜索，直到找到所要求的解或解空间中已无活结点时为止。

回溯法与穷举法有某些联系，它们都是基于试探的。穷举法要将一个解的各个部分全部生成后，才检查是否满足条件，若不满足，则直接放弃该完整解，然后再尝试另一个可能的完整解，它并没有沿着一个可能的完整解的各个部分逐步回退生成解的过程。而对于回溯法，一个解的各个部分是逐步生成的，当发现当前生成的某部分不满足约束条件时，就放弃该步所做的工作，退到上一步进行新的尝试，而不是放弃整个解重来。

回溯法解题的关键要素

确定了问题的解空间结构后，回溯法将从开始结点(根结点)出发，以深度优先的方式搜索整个解空间。开始结点成为活结点，同时也成为扩展结点。在当前的扩展结点处，向纵深方向搜索并移至一个新结点，这个新结点就成为一个新的活结点，并成为当前的扩展结点。如果在当前的扩展结点处不能再向纵深方向移动，则当前的扩展结点就成为死结点。此时应往回移动(回溯)至最近的一个活结点处，并使其成为当前的扩展结点。回溯法以上述工作方式递归地在解空间中搜索，直至找到所要求的解或解空间中已无活结点时为止。

运用回溯法解题的关键要素有以下三点：

(1) 针对给定的问题，定义问题的解空间；

(2) 确定易于搜索的解空间结构；

(3) 以深度优先方式搜索解空间，并且在搜索过程中用剪枝函数避免无效搜索。

回溯解决的问题

组合问题：N个数里面按一定规则找出k个数的集合
排列问题：N个数按一定规则全排列，有几种排列方式
切割问题：一个字符串按一定规则有几种切割方式
子集问题：一个N个数的集合里有多少符合条件的子集
棋盘问题：N皇后，解数独等等

所以，我们上面这题组合题，就是回溯来解决啦

来看看，第一版题解

public class fourteen {
    public static void main(String[] args) {
        combine(4, 2);
    }


    public static List<List<Integer>> combine(int n, int k) {
        //这个是我用来放结果的
        List<List<Integer>> res = new ArrayList<>();
        //这个是用来方我们走过的路径的，这不好用List,可以用队列，因为我们要回退上一步
        LinkedList<Integer> temp = new LinkedList<>();
        backtracking(1, res, k, temp, n);
        return res;

    }

    private static void backtracking(int i, List<List<Integer>> res, int k, LinkedList<Integer> temp, int n) {
        //这是递归的结束条件
        if (temp.size() == k) {
            res.add(new ArrayList<>(temp));
            return;
        }
        //这里的for循环，表示我们的深入遍历，遍历到最后，然后再一步步回溯，就是把先把每个一个向下走的路走完，再走其他的分叉
        for (int j = i; j <= n; j++) {
            temp.add(j);
            back(j + 1, res, k, temp, n);
            temp.removeLast();
        }
    }
}
复制代码

其实我们发现其实还有优化的点，我们称之为减枝

第二版，减枝

public static List<List<Integer>> combine(int n, int k) {
    //这个是我用来放结果的
    List<List<Integer>> res = new ArrayList<>();
    //这个是用来方我们走过的路径的，这不好用List,可以用队列，因为我们要回退上一步
    LinkedList<Integer> temp = new LinkedList<>();
    backtracking(1, res, k, temp, n);
    return res;

}

private static void backtracking(int i, List<List<Integer>> res, int k, LinkedList<Integer> temp, int n) {
    //这是递归的结束条件
    if (temp.size() == k) {
        res.add(new ArrayList<>(temp));
        return;
    }
    //这里的for循环，表示我们的深入遍历，遍历到最后，然后再一步步回溯，就是把先把每个一个向下走的路走完，再走其他的分叉,减枝的地方就是在 我们遍历的条件，之前是j<=n,现在是j <= n-(k-temp.size())+1
    for (int j = i; j <= n-(k-temp.size())+1; j++) {
        temp.add(j);
        backtracking(j + 1, res, k, temp, n);
        temp.removeLast();
    }
}
复制代码

减枝的地方就是在我们遍历的条件，之前是j<=n,现在是j <= n-(k-temp.size())+1

我们来看看为啥能这样干，大家想，我们比如我们要n=4,k=3的话，那其实如果我们从2点地方遍历是可以的，因为后面有3，4，可以，但是如果我的开始index是3，是不是其实我没必要去深度遍历了，因为后面不管是怎么样，它后面就只有4，最多也就3，4，根本到不了 k=3,这就剪枝

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

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

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

所以减枝条件就是 j <= n-(k-temp.size())+1，大家可以把 n=4,k=3代入进去套一下就好了

回溯模版

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

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

复制代码

结束

好了，今天就到了这了，接下来，几天我们可以继续来分享回溯相关的题目，加强练习

六六力扣刷题回溯之combinations（组合）

前言

题目