216. 组合总和 III

216. 组合总和 III

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\ast 2^n)$
空间复杂度: $O(n)$

总结

开篇就介绍了本题与77.组合 的区别，相对来说加了元素总和的限制，如果做完77.组合 再做本题在合适不过。

分析完区别，依然把问题抽象为树形结构，按照回溯三部曲进行讲解，最后给出剪枝的优化。

相信做完本题，大家对组合问题应该有初步了解了。