216. 组合总和 III
找出所有相加之和为 n
的 k
个数的组合,且满足下列条件:
- 只使用数字
1
到9
- 每个数字 最多使用一次
- 返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次,组合可以以任何顺序返回。
示例 1:
输入: k = 3, n = 7
输出: [[1,2,4]]
解释:
1 + 2 + 4 = 7
没有其他符合的组合了。
示例 2:
输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]
解释:
1 + 2 + 6 = 9
1 + 3 + 5 = 9
2 + 3 + 4 = 9
没有其他符合的组合了。
示例 3:
输入: k = 4, n = 1
输出: []
解释: 不存在有效的组合。
在[1,9]范围内使用4个不同的数字,我们可以得到的最小和是1+2+3+4 = 10,
因为10 > 1,没有有效的组合。
提示:
- 2 <= k <= 9
- 1 <= n <= 60
思路
本题就是在[1,2,3,4,5,6,7,8,9]
这个集合中找到和为n
的k
个数的组合。
相对于77. 组合【含回溯详解、N叉树类比、剪枝优化】,无非就是多了一个限制,本题是要找到和为n
的k
个数的组合,而整个集合已经是固定的了[1,...,9]
。
想到这一点了,做过77. 组合
之后,本题是简单一些了。
本题k
相当于树的深度,9
(因为整个集合就是9
个数)就是树的宽度。
例如 k = 2,n = 4
的话,就是在集合[1,2,3,4,5,6,7,8,9]
中求 k(个数) = 2, n(和) = 4
的组合。
选取过程如图:
图中,可以看出,只有最后取到集合(1,3)
和为4
符合条件。
回溯三部曲
1.确定递归函数参数
和77. 组合
一样,依然需要一维切片path
来存放符合条件的结果,二维切片res
来存放结果集。
至于为什么取名为path
?从上面树形结构中,可以看出,结果其实就是一条根节点到叶子节点的路径。
接下来还需要如下参数:
targetSum(int)
目标和,也就是题目中的n
。k(int)
就是题目中要求k
个数的集合。sum(int)
为已经收集的元素的总和,也就是path
里元素的总和,不过一般是通过n
不断减去选取的元素数值,如果刚好k
个数时,减到0
即可认为当前路径和为n
,所以该参数可以优化掉。startIndex(int)
为下一层for
循环搜索的起始位置。
所以代码如下:
func backtracking(k int,n int,res *[][]int,path *[]int,startIndex int){}
还要强调一下,回溯法中递归函数参数很难一次性确定下来,一般先写逻辑,需要啥参数了,填什么参数。
2.确定终止条件
什么时候终止呢?
在上面已经说了,k
其实就已经限制树的深度,因为就取k
个元素,树再往下深入没有意义。
所以如果len(*path)
和 k
相等了,就终止。
如果此时path
里收集到的元素和和n
相同了(即n
为0
),就用res
收集当前的结果。
所以 终止代码如下:
// 数字个数到达k个时,可以返回了,返回前根据和是否为0了,将当前路径结果加到最终结果中
if len(*path) == k {
if n == 0 {
*res = append(*res,append([]int(nil),*path...))
}
return
}
3.单层搜索过程
本题和77. 组合
区别之一就是集合固定的就是9
个数[1,...,9]
,所以for
循环固定i<=9
处理过程就是 path
收集每次选取的元素,相当于树型结构里的边,n
减去每次选取的元素来统计path
里元素的总和。
代码如下:
for i := startIndex;i <= 9 ;i++ {
*path = append(*path,i)
backtracking(k,n - i,res,path,i + 1)// 注意i+1调整startIndex
*path = (*path)[0:len(*path) - 1] // 回溯
}
别忘了处理过程 和 回溯过程是一一对应的,path处理有加,回溯就要有减!而n有减,回溯就要有加,但是这里写在参数中了,利用了值传递,本身n在当前层未变的性质,所以backtracing中其实隐含了n的回溯
参照回溯算法模板
,不难写出如下Go
代码:
func combinationSum3(k int, n int) [][]int {
res := make([][]int,0)
path := make([]int,0)
backtracking(k,n,&res,&path,1)
return res
}
func backtracking(k int,n int,res *[][]int,path *[]int,startIndex int){
// 数字个数到达k个时,可以返回了,返回前根据和是否为0了,将当前路径结果加到最终结果中
if len(*path) == k {
if n == 0 {
*res = append(*res,append([]int(nil),*path...))
}
return
}
for i := startIndex;i <= 9;i++ {
*path = append(*path,i)
backtracking(k,n - i,res,path,i + 1)
*path = (*path)[0:len(*path) - 1]
}
}
剪枝
这道题目,剪枝操作其实是很容易想到了,想必大家看上面的树形图的时候已经想到了。
已选元素总和如果已经大于n
(图中数值为4
)了,那么往下继续深入递归遍历就没有意义了,直接剪掉。
那么剪枝的地方可以放在递归函数开始的地方,剪枝代码如下:
// 剪枝 和已经变为负数,继续往下更深处递归,n会越来越小,不可能等于0了
if n < 0 {
return
}
for
循环的范围也可以剪枝,i <= 9 -(k - len(*path)) + 1
就可以了。
最后Go
代码如下:
func combinationSum3(k int, n int) [][]int {
res := make([][]int,0)
path := make([]int,0)
backtracking(k,n,&res,&path,1)
return res
}
func backtracking(k int,n int,res *[][]int,path *[]int,startIndex int){
// 剪枝 和已经变为负数,继续往深处递归,n会越来越小,不可能等于0了
if n < 0 {
return
}
// 数字个数到达k个时,可以返回了,返回前根据和是否为0了,将当前路径结果加到最终结果中
if len(*path) == k {
if n == 0 {
*res = append(*res,append([]int(nil),*path...))
}
return
}
// 剪枝i至多从9 - (k - len(*path)) + 1开始选,才能选到k个数,
for i := startIndex;i <= 9 - (k - len(*path)) + 1 ;i++ {
*path = append(*path,i)
backtracking(k,n - i,res,path,i + 1)
*path = (*path)[0:len(*path) - 1]
}
}
时间复杂度:
O
(
n
∗
2
n
)
O(n * 2^n)
O(n∗2n)
空间复杂度:
O
(
n
)
O(n)
O(n)
总结
开篇就介绍了本题与77.组合
的区别,相对来说加了元素总和的限制,如果做完77.组合
再做本题在合适不过。
分析完区别,依然把问题抽象为树形结构,按照回溯三部曲进行讲解,最后给出剪枝的优化。
相信做完本题,大家对组合问题应该有初步了解了。