🌸题目
🍁给定两个整数 n 和 k,返回 1 … n 中所有可能的 k 个数的组合。
示例:
输入: n = 4, k = 2
输出:
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]
🌸分析
- 如果解决一个问题有多个步骤,每一个步骤有多种方法,题目又要我们找出所有的方法,可以使用回溯算法;
- 回溯算法是在一棵树上的 深度优先遍历(因为要找所有的解,所以需要遍历);
- 组合问题,相对于排列问题而言,不计较一个组合内元素的顺序性(即 [1, 2, 3] 与 [1, 3, 2] 认为是同一个组合),因此很多时候需要按某种顺序展开搜索,这样才能做到不重不漏。
回溯算法首先需要画出递归树,不同的树决定了不同的代码实现。
🌸解法一:根据搜索起点画出二叉树
既然是树形问题上的 深度优先遍历,因此首先画出树形结构。例如输入:n = 4, k = 2,我们可以发现如下递归结构:
- 如果组合里有 1 ,那么需要在 [2, 3, 4] 里再找 1 个数;
- 如果组合里有 2 ,那么需要在 [3, 4] 里再找 1数。注意:这里不能再考虑 1,因为包含 1 的组合,在第 1 种情况中已经包含。
依次类推(后面部分省略),以上描述体现的 递归 结构是:在以 n 结尾的候选数组里,选出若干个元素。
说明:
- 叶子结点的信息体现在从根结点到叶子结点的路径上,因此需要一个表示路径的变量 path,它是一个列表,特别地,path 是一个栈;
- 每一个结点递归地在做同样的事情,区别在于搜索起点,因此需要一个变量 start ,表示在区间 [begin, n] 里选出若干个数的组合;
- 可能有一些分支没有必要执行,我们放在优化中介绍。
public List<List<Integer>> combine(int n, int k){
List<List<Integer>> res = new ArrayList<>();
if(k <= 0 || n < k) {
return res;
}
//从1开始是题目的设定
Deque<Integer> path = new ArrayDeque<>();
dfs(n, k, 1, path, res);
return res;
}
private static void dfs(int n, int k, int begin, Deque<Integer> path, List<List<Integer>> res) {
//递归终止条件是:path的长度等于K
if(k == path.size()) {
res.add(new ArrayList<>(path));
return;
}
//遍历可能的搜索起点
for(int i = begin; i <= n; i++) {
//向路径变量里添加一个数
path.addLast(i);
//下一轮搜索,设置搜索起点要加一,因为组合数里应该不欲奴徐出现重复数
dfs(n, k, begin + 1, path, res);
//深度优先搜索遍历有回头的时候,因此需要回溯
path.removeLast();
}
}
🌸解法二:分析搜索起点的上界进行剪枝
事实上,如果 n = 7, k = 4,从 55 开始搜索就已经没有意义了,这是因为:即使把 55 选上,后面的数只有 66 和 77,一共就 33 个候选数,凑不出 44 个数的组合。因此,搜索起点有上界,这个上界是多少,可以举几个例子分析。
分析搜索起点的上界,其实是在深度优先遍历的过程中剪枝,剪枝可以避免不必要的遍历,剪枝剪得好,可以大幅度节约算法的执行时间。
当 n 很大的时候,能少遍历很多结点,节约了时间。
例如:n = 6 ,k = 4
。
path.size() == 1
的时候,接下来要选择 3个数,搜索起点最大是 4,最后一个被选的组合是 [4, 5, 6]
;
path.size() == 2
的时候,接下来要选择 2 个数,搜索起点最大是 5,最后一个被选的组合是 [5, 6]
;
path.size() == 3
的时候,接下来要选择 1 个数,搜索起点最大是 6,最后一个被选的组合是 [6]
;
再如:n = 15 ,k = 4
。
path.size() == 1
的时候,接下来要选择 3 个数,搜索起点最大是 13,最后一个被选的是 [13, 14, 15]
;
path.size() == 2
的时候,接下来要选择 2 个数,搜索起点最大是 14,最后一个被选的是 [14, 15]
;
path.size() == 3
的时候,接下来要选择 1 个数,搜索起点最大是 15,最后一个被选的是 [15]
;
可以归纳出:
搜索起点的上界 + 接下来要选择的元素个数 - 1 = n
其中,接下来要选择的元素个数 = k - path.size()
,整理得到:
搜索起点的上界 = n - (k - path.size()) + 1
所以,我们的剪枝过程就是:把 i <= n 改成 i <= n - (k - path.size()) + 1
:
public List<List<Integer>> combine(int n, int k){
List<List<Integer>> res = new ArrayList<>();
if(k <= 0 || n < k) {
return res;
}
//从1开始是题目的设定
Deque<Integer> path = new ArrayDeque<>();
dfs(n, k, 1, path, res);
return res;
}
private static void dfs(int n, int k, int begin, Deque<Integer> path, List<List<Integer>> res) {
//递归终止条件是:path的长度等于K
if(k == path.size()) {
res.add(new ArrayList<>(path));
return;
}
//遍历可能的搜索起点
for(int i = begin; i <= n - (k - path.size()) + 1; i++) {
//向路径变量里添加一个数
path.addLast(i);
//下一轮搜索,设置搜索起点要加一,因为组合数里应该不欲奴徐出现重复数
dfs(n, k, begin + 1, path, res);
//深度优先搜索遍历有回头的时候,因此需要回溯
path.removeLast();
}
}