题目
给定两个整数 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(路径，选择列表); // 递归 回溯，撤销处理结果 } } 复制代码
结束
好了，今天就到了这了，接下来，几天我们可以继续来分享回溯相关的题目，加强练习
