77. 组合
1.题目描述
给定两个整数
n和k，返回范围[1, n]中所有可能的k个数的组合。你可以按 任何顺序 返回答案。
2.解题思路
那么我把组合问题抽象为如下树形结构：
- 可以看出这个棵树，一开始集合是 1，2，3，4， 从左向右取数，取过的数，不在重复取。
- 第一次取1，集合变为2，3，4 ，因为k为2，我们只需要再取一个数就可以了，分别取2，3，4，得到集合[1,2] [1,3] [1,4]，以此类推。
- 每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围。
- 图中可以发现n相当于树的宽度，k相当于树的深度。
- 那么如何在这个树上遍历，然后收集到我们要的结果集呢？
- 图中每次搜索到了叶子节点，我们就找到了一个结果。
- 相当于只需要把达到叶子节点的结果收集起来，就可以求得 n个数中k个数的组合集合。
3.代码实现
1.确定递归函数的参数和返回值：
递归函数定义：范围 [1, n] 中所有可能的 k 个数的组合放到结果集res中。
/**
* @param n 集合[1, n]
* @param k K个数的组合
* @param startIndex 每次遍历的起始位置
* @param res 需要的结果集
* @param path 路径参数
* 递归函数定义：范围 [1, n] 中所有可能的 k 个数的组合放到结果集res中
*/
public void trackBacking(int n, int k, int startIndex,
List<List<Integer>> res, LinkedList<Integer> path) {}从下图中红线部分可以看出，在集合[1,2,3,4]取1之后，下一层递归，就要在[2,3,4]中取数了，那么下一层递归如何知道从[2,3,4]中取数呢，靠的就是startIndex。
所以需要startIndex来记录下一层递归，搜索的起始位置。
2.确定终止条件：
- 什么时候到达所谓的叶子节点了呢？
- path这个数组的大小如果达到k，说明我们找到了一个子集大小为k的组合了，在图中path存的就是根节点到叶子节点的路径。
此时用result二维数组，把path保存起来，并终止本层递归。
所以终止条件代码如下：
//终止条件
if (path.size() == k) {
res.add(new ArrayList<>(path));
return;
}3.确定单层递归的逻辑：
回溯法的搜索过程就是一个树型结构的遍历过程，在如下图中，可以看出for循环用来横向遍历，递归的过程是纵向遍历。
- 如此我们才遍历完图中的这棵树。for循环每次从startIndex开始遍历，然后用path保存取到的节点i。
- 代码如下：
//单层递归逻辑
for (int i = startIndex; i <= n; i++) {
path.add(i);// 处理节点
//递归：控制树的纵向遍历，注意下一层搜索要从i+1开始
trackBacking(n, k, i + 1, res, path);
path.removeLast();// 回溯，撤销处理的节点
}完整代码如下：
class Solution {
//77. 组合
public List<List<Integer>> combine(int n, int k) {
List<List<Integer>> res = new ArrayList<>();
if (n == 0) {
return res;
}
LinkedList<Integer> path = new LinkedList<>();
trackBacking(n, k, 1, res, path);
return res;
}
/**
* @param n 集合[1, n]
* @param k K个数的组合
* @param startIndex 每次遍历的起始位置
* @param res 需要的结果集
* @param path 路径参数
* 递归函数定义：范围 [1, n] 中所有可能的 k 个数的组合放到结果集res中
*/
public void trackBacking(int n, int k, int startIndex,
List<List<Integer>> res, LinkedList<Integer> path) {
//终止条件
if (path.size() == k) {
res.add(new ArrayList<>(path));
return;
}
//单层递归逻辑
for (int i = startIndex; i <= n; i++) {
path.add(i);// 处理节点
//递归：控制树的纵向遍历，注意下一层搜索要从i+1开始
trackBacking(n, k, i + 1, res, path);
path.removeLast();// 回溯，撤销处理的节点
}
}
}4.剪枝优化
我们说过，回溯法虽然是暴力搜索，但也有时候可以有点剪枝优化一下的。
在遍历的过程中有如下代码：
//单层递归逻辑
for (int i = startIndex; i <= n; i++) {
path.add(i);// 处理节点
//递归：控制树的纵向遍历，注意下一层搜索要从i+1开始
trackBacking(n, k, i + 1, res, path);
path.removeLast();// 回溯，撤销处理的节点
}
- 这个遍历的范围是可以剪枝优化的，怎么优化呢？
- 来举一个例子，n = 4，k = 4的话，那么第一层for循环的时候，从元素2开始的遍历都没有意义了。 在第二层for循环，从元素3开始的遍历都没有意义了。
- 这么说有点抽象，如图所示：
- 图中每一个节点（图中为矩形），就代表本层的一个for循环，那么每一层的for循环从第二个数开始遍历的话，都没有意义，都是无效遍历。
- 所以，可以剪枝的地方就在递归中每一层的for循环所选择的起始位置。
- 如果for循环选择的起始位置之后的元素个数 已经不足 我们需要的元素个数了，那么就没有必要搜索了。
- 注意代码中i，就是for循环里选择的起始位置。
for (int i = startIndex; i <= n; i++) {}接下来看一下优化过程如下：
已经选择的元素个数：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++) {}优化后的完整代码如下：
class Solution {
//77. 组合
public List<List<Integer>> combine(int n, int k) {
List<List<Integer>> res = new ArrayList<>();
if (n == 0) {
return res;
}
LinkedList<Integer> path = new LinkedList<>();
trackBacking(n, k, 1, res, path);
return res;
}
/**
* @param n 集合[1, n]
* @param k K个数的组合
* @param startIndex 每次遍历的起始位置
* @param res 需要的结果集
* @param path 路径参数
* 递归函数定义：范围 [1, n] 中所有可能的 k 个数的组合放到结果集res中
*/
public void trackBacking(int n, int k, int startIndex, List<List<Integer>> res, LinkedList<Integer> path) {
//终止条件
if (path.size() == k) {
res.add(new ArrayList<>(path));
return;
}
//单层递归逻辑
for (int i = startIndex; i <= n-(k-path.size())+1; i++) {
path.add(i);// 处理节点
//递归：控制树的纵向遍历，注意下一层搜索要从i+1开始
trackBacking(n, k, i + 1, res, path);
path.removeLast();// 回溯，撤销处理的节点
}
}
}216. 组合总和 III
1.题目描述
- 找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：
- 只使用数字1到9
- 每个数字 最多使用一次
- 返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。
2.解题思路
- 本题就是在[1,2,3,4,5,6,7,8,9]这个集合中找到和为n的k个数的组合。
- 相对于77. 组合 (opens new window)，无非就是多了一个限制，本题是要找到和为n的k个数的组合，而整个集合已经是固定的了[1,...,9]。
- 想到这一点了，做过77. 组合 (opens new window)之后，本题是简单一些了。
- 本题k相当于了树的深度，9（因为整个集合就是9个数）就是树的宽度。
- 例如 k = 2，n = 4的话，就是在集合[1,2,3,4,5,6,7,8,9]中求 k（个数） = 2, n（和） = 4的组合。
- 选取过程如图：
图中，可以看出，只有最后取到集合（1，3）和为4符合条件。
3.代码实现
1.确定递归函数的参数和返回值：
递归函数定义：
- 1.范围 [1, 9] 中所有可能的 k 个数的组合之和等于n。
- 2.组合放到结果集res中。
/**
* @param n 目标和等于n
* @param k K个数的组合
* @param startIndex 每次遍历的起始位置
* @param res 需要的结果集
* @param path 路径参数
* 递归函数定义：1.范围 [1, 9] 中所有可能的 k 个数的组合之和等于n
* 2.组合放到结果集res中
*/
public void trackBacking2(int n, int k, int startIndex, int sum,
List<List<Integer>> res, LinkedList<Integer> path) {}2.确定终止条件：
- 什么时候终止呢？
- 在上面已经说了，k其实就已经限制树的深度，因为就取k个元素，树再往下深了没有意义。
- 所以如果path.size() 和 k相等了，就终止。
- 如果此时path里收集到的元素和（sum） 和 n相同了，就用result收集当前的结果。
//终止条件
if (path.size() == k && sum == n) {
res.add(new ArrayList<>(path));
return;
}3.确定单层递归的逻辑：
本题和77. 组合区别之一就是集合固定的就是9个数[1,...,9]，所以for循环固定i<=9。
处理过程就是 path收集每次选取的元素，相当于树型结构里的边，sum来统计path里元素的总和。
代码如下：
//单层递归逻辑
for (int i = startIndex; i <= 9; i++) {
path.add(i);// 处理节点
sum += i;
//递归：控制树的纵向遍历，注意下一层搜索要从i+1开始
trackBacking2(n, k, i + 1, sum, res, path);
sum -= i;
path.removeLast();// 回溯，撤销处理的节点
}完整代码如下：
class Solution {
//216. 组合总和 III--使用k个数（范围1到9）让它们的和等于n
public List<List<Integer>> combinationSum3(int k, int n) {
List<List<Integer>> res = new ArrayList<>();
if (n == 0) {
return res;
}
LinkedList<Integer> path = new LinkedList<>();
trackBacking2(n, k, 1, 0, res, path);
return res;
}
/**
* @param n 目标和等于n
* @param k K个数的组合
* @param startIndex 每次遍历的起始位置
* @param res 需要的结果集
* @param path 路径参数
* 递归函数定义：1.范围 [1, 9] 中所有可能的 k 个数的组合之和等于n
* 2.组合放到结果集res中
*/
public void trackBacking2(int n, int k, int startIndex, int sum,
List<List<Integer>> res, LinkedList<Integer> path) {
//终止条件
if (path.size() == k && sum == n) {
res.add(new ArrayList<>(path));
return;
}
//单层递归逻辑
for (int i = startIndex; i <= 9; i++) {
path.add(i);// 处理节点
sum += i;
//递归：控制树的纵向遍历，注意下一层搜索要从i+1开始
trackBacking2(n, k, i + 1, sum, res, path);
sum -= i;
path.removeLast();// 回溯，撤销处理的节点
}
}
}4.剪枝优化
这道题目，剪枝操作其实是很容易想到了，想必大家看上面的树形图的时候已经想到了。
如图：
已选元素总和如果已经大于n（图中数值为4）了，那么往后遍历就没有意义了，直接剪掉。
那么剪枝的地方可以放在递归函数开始的地方，剪枝代码如下：
if (sum > n) {
return;
}和77. 组合一样，for循环的范围也可以剪枝，i <= 9 - (k - path.size()) + 1就可以了。
for (int i = startIndex; i <= 9 - (k - path.size()) + 1; i++) {}完整代码如下：
class Solution {
//216. 组合总和 III--使用k个数（范围1到9）让它们的和等于n
public List<List<Integer>> combinationSum3(int k, int n) {
List<List<Integer>> res = new ArrayList<>();
if (n == 0) {
return res;
}
LinkedList<Integer> path = new LinkedList<>();
trackBacking2(n, k, 1, 0, res, path);
return res;
}
/**
* @param n 目标和等于n
* @param k K个数的组合
* @param startIndex 每次遍历的起始位置
* @param res 需要的结果集
* @param path 路径参数
* 递归函数定义：1.范围 [1, 9] 中所有可能的 k 个数的组合之和等于n
* 2.组合放到结果集res中
*/
public void trackBacking2(int n, int k, int startIndex, int sum,
List<List<Integer>> res, LinkedList<Integer> path) {
if (sum > n) {
return;
}
//终止条件
if (path.size() == k && sum == n) {
res.add(new ArrayList<>(path));
return;
}
//单层递归逻辑
for (int i = startIndex; i <= 9 - (k - path.size()) + 1; i++) {
path.add(i);// 处理节点
sum += i;
//递归：控制树的纵向遍历，注意下一层搜索要从i+1开始
trackBacking2(n, k, i + 1, sum, res, path);
sum -= i;
path.removeLast();// 回溯，撤销处理的节点
}
}
}17. 电话号码的字母组合
1.题目描述
- 给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按任意顺序返回。
- 给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
2.解题思路
从示例上来说，输入"23"，最直接的想法就是两层for循环遍历了吧，正好把组合的情况都输出了。
如果输入"233"呢，那么就三层for循环，如果"2333"呢，就四层for循环.......
大家应该感觉出和77.组合 (opens new window)遇到的一样的问题，就是这for循环的层数如何写出来，此时又是回溯法登场的时候了。
理解本题后，要解决如下两个问题：
- 数字和字母如何映射？
回溯法来解决n个for循环的问题
3.代码实现
数字和字母如何映射？
可以使用map或者定义一个二维数组，例如：string letterMap[10]，来做映射，我这里定义一个二维数组，代码如下：
String[] strArray = { "", // 0
"", // 1
"abc", // 2
"def", // 3
"ghi", // 4
"jkl", // 5
"mno", // 6
"pqrs", // 7
"tuv", // 8
"wxyz", // 9
}
1.确定递归函数的参数和返回值：
递归函数定义：把digits的数字字符串代表的字母组合放到结果集res中。
/**
* @param digits 传进来的数字字符串
* @param index 代表在数字字符串的位置
* 这个index是记录遍历第几个数字了
* 就是用来遍历digits的（题目中给出数字字符串），同时index也表示树的深度。
* 递归函数定义：把digits的数字字符串代表的字母组合放到结果集res中
*/
public void trackBacking3(String digits, int index) {}例如：输入："23"，抽象为树形结构，如图所示：
图中可以看出遍历的深度，就是输入"23"的长度，而叶子节点就是我们要收集的结果，输出["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]。
2.确定终止条件：
- 例如输入用例"23"，两个数字，那么根节点往下递归两层就可以了，叶子节点就是要收集的结果集。
- 那么终止条件就是如果index 等于 输入的数字个数（digits.size）了（本来index就是用来遍历digits的）。
- 然后收集结果，结束本层递归。
//递归终止条件-当前索引位置到了字符串的末尾
if (index == digits.length()) {
res.add(sb.toString());
return;
}3.确定单层递归的逻辑：
- 1.取出每个字符代表的数字。
- 2.将这个数字在字符数组中代表的字符取出来。
- 3.遍历这个字符串。
- 4.取出遍历的字符，放进字符串中。
- 5.递归处理，index位置加1，代表此时处理的字符到了 digits的下一个位置。
- 6.回溯处理。
//单层递归逻辑
//1.取出每个字符代表的数字
int num = digits.charAt(index) - '0';
//2.将这个数字在字符数组中代表的字符取出来
String s = strArray[num];
//3.遍历这个字符串
for (int j = 0; j < s.length(); j++) {
//4.取出遍历的字符，放进字符串中
sb.append(s.charAt(j));
//5.递归处理，index位置加1，代表此时处理的字符到了 digits的下一个位置
trackBacking3(digits, index + 1);
//6.回溯处理
sb.deleteCharAt(sb.length() - 1);
}完整代码如下：
class Solution {
//17. 电话号码的字母组合
String[] strArray = {"", "", "abc", "def", "ghi",
"jkl", "mno", "pqrs", "tuv", "wxyz"};
List<String> res;
StringBuilder sb;
public List<String> letterCombinations(String digits) {
res = new ArrayList<>();
if (digits == null || digits.length() == 0) {
return res;
}
sb = new StringBuilder();
trackBacking3(digits, 0);
return res;
}
/**
* @param digits 传进来的数字字符串
* @param index 代表在数字字符串的位置
* 递归函数定义：把digits的数字字符串代表的字母组合放到结果集res中
*/
public void trackBacking3(String digits, int index) {
//递归终止条件-当前索引位置到了字符串的末尾
if (index == digits.length()) {
res.add(sb.toString());
return;
}
//单层递归逻辑
//1.取出每个字符代表的数字
int num = digits.charAt(index) - '0';
//2.将这个数字在字符数组中代表的字符取出来
String s = strArray[num];
//3.遍历这个字符串
for (int j = 0; j < s.length(); j++) {
//4.取出遍历的字符，放进字符串中
sb.append(s.charAt(j));
//5.递归处理，index位置加1，代表此时处理的字符到了 digits的下一个位置
trackBacking3(digits, index + 1);
//6.回溯处理
sb.deleteCharAt(sb.length() - 1);
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
