77. 组合

77. 组合

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

示例 1：

输入：n = 4, k = 2
输出：
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

示例 2：

输入：n = 1, k = 1
输出：[[1]]

提示：

• 1 <= n <= 20
• 1 <= k <= n

思路

暴力法

本题是回溯法的经典题目。

直接的解法当然是使用for循环，例如示例中k为2，很容易想到用两个for循环，这样就可以输出和示例中一样的结果。

代码如下：

n := 4;
for i := 1; i <= n; i++ {
    for j := i + 1; j <= n; j++ {
        fmt.Printf("%d %d\n",i,j)
    }
}

输入：n = 100, k = 3 那么就三层for循环，代码如下：

n := 100;
for  i := 1; i <= n; i++ {
    for j := i + 1; j <= n; j++ {
        for  u := j + 1; u <= n; n++ {
       	 fmt.Printf("%d %d %d\n",i,j,u)
        }
    }
}

如果n为100，k为50呢，那就50层for循环，是不是开始窒息。

此时就会发现虽然想暴力搜索，但是用for循环嵌套连暴力都写不出来！

咋整？

回溯搜索法来了，虽然回溯法也是暴力，但至少能写出来，不像for循环嵌套k层让人绝望。

那么回溯法怎么暴力搜呢？

上面我们说了要解决 n为100，k为50的情况，暴力写法需要嵌套50层for循环，那么回溯法就用递归来解决嵌套层数的问题。

递归来做层叠嵌套（可以理解是开k层for循环），每一次的递归中嵌套一个for循环，那么递归就可以用于解决多层嵌套循环的问题了。

此时递归的层数大家应该知道了，例如：n为100，k为50的情况下，就是递归50层。

一些同学本来对递归就懵，回溯法中递归还要嵌套for循环，可能就直接晕倒了！

如果脑洞模拟回溯搜索的过程，绝对可以让人窒息，所以需要抽象图形结构来进一步理解。

回溯与N叉树类比

我们在关于回溯算法基础中说到回溯法解决的问题都可以抽象为树形结构（N叉树），用树形结构来理解回溯就容易多了。

那么我把组合问题抽象为如下树形结构：

可以看出这棵树，一开始集合是 1，2，3，4， 从左向右取数，取过的数，不再重复取。

第一次取1，集合变为2，3，4 ，因为k为2，我们只需要再取一个数就可以了，分别取2，3，4，得到集合[1,2] [1,3] [1,4]，以此类推。

每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围。

图中可以发现n相当于树的宽度，k相当于树的深度。

那么如何在这个树上遍历，然后收集到我们要的结果集呢？

图中每次搜索到了叶子节点，我们就找到了一个结果。

相当于只需要把达到叶子节点的结果收集起来，就可以求得 n个数中k个数的组合集合。

如果用N叉树的前序遍历类比一下或许就更好理解了。如下是N叉树前序遍历的代码，可以看到每遍历到一个节点后，就递归遍历它所有的子孩子，同样，它子孩子也可能还有子孩子，且各子孩子的子孩子数量可以是不一致的。

N 叉树前序遍历

/**
 * Definition for a Node.
 * type Node struct {
 *     Val int
 *     Children []*Node
 * }
 */

func preorder(root *Node) []int {
    if root == nil {
        return nil
    }

    res := make([]int,0)
    dfs(root,&res)

    return res
}

func dfs(root *Node,res *[]int) {
    // 递归终止条件
    if root == nil {
        return 
    }
    
    *res = append(*res,root.Val)
    // 递归前序遍历当前节点的每一个子节点
    for i := 0;i < len(root.Children);i++ {
        dfs(root.Children[i],res)
    }
}

这时候再来看下图

是不是可以理解成根节点有四个子孩子（当然，这里根节点在上图没有体现，可以想象图中第一层是根节点的所有子孩子），分别是1,2,3,4，我们递归遍历孩子1，然后发现1又有三个子孩子2,3,4，继续递归遍历1的这三个子孩子，都遍历完后归上去，到达第一层，此时再开始遍历根节点的第二个孩子2，同样发现2也有两个子孩子3,4，所以遍历3和4，依次递推，直到全部节点遍历结束。

小结： 回溯可以类比成一个N叉树，每一层的for就是横向选择一个子孩子，纵向就是递归遍历该子孩子的子孩子，可以将组合题目的代码和N叉树的递归代码对比看下，更有感觉

回溯法三部曲

1.递归函数的返回值以及参数
函数里一定有两个参数，既然是集合n里面取k个数，那么n和k是两个int型的参数。

在这里还需要两个切片，一个用来存放符合条件的单一结果path，一个用来存放符合条件结果的集合res。

然后还需要一个参数，为int型变量startIndex，这个参数用来记录本层递归的中，集合从哪里开始遍历（集合就是[1,...,n] ）。

为什么要有这个startIndex呢？

startIndex 就是防止出现重复的组合。

从下图中红线部分可以看出，在集合[1,2,3,4]取1之后，下一层递归，就要在[2,3,4]中取数了，那么下一层递归如何知道从[2,3,4]中取数呢，靠的就是startIndex。

所以需要startIndex来记录下一层递归时，搜索的起始位置。

那么backtracing函数定义整体代码如下：

注意res和path都是切片的指针类型，因为在递归的时候，他们两个都可能产生扩容，改变指向，所以需要传指针，保证操作的是我们最开始传入的切片。

func backtracing(n int,k int,res *[][]int,path *[]int,startIndex int) {}

2.回溯函数终止条件
什么时候到达所谓的叶子节点了呢？

path这个数组的大小如果达到k，说明我们找到了一个子集大小为k的组合了，在图中path存的就是根节点到叶子节点的路径。

如图红色部分：

此时用res二维切片，把path保存起来，并终止本层递归。

所以终止条件代码如下：

if len(*path) == k {
    // 需要添加的是path的副本，注意如下添加副本技巧
     *res = append(*res,append([]int(nil),*path...))
     return
 }

3.单层搜索的过程
回溯法的搜索过程就是一个树型结构的遍历过程，在如下图中，可以看出for循环用来横向遍历，递归的过程是纵向遍历。

如此我们才遍历完图中的这棵树。

for循环每次从startIndex开始遍历，然后用path保存取到的节点i。

代码如下：

// 控制树的横向遍历
for i := startIndex;i <= n;i++ {
    *path = append(*path,i) // 处理节点
    // 递归：控制树的纵向遍历，注意下一层搜索要从i+1开始
    backtracing(n,k,res,path,i + 1)
    *path = (*path)[0:len(*path) - 1]  // 回溯，撤销处理的节点
}

可以看出backtracking（递归函数）通过不断调用自己一直往深处遍历，总会遇到叶子节点，遇到了叶子节点就要返回。

backtracking的下面部分就是回溯的操作了，撤销本次处理的结果。

关键地方都讲完了，组合问题Go完整代码如下：

func combine(n int, k int) [][]int {
    res := make([][]int,0)
    path := make([]int,0)
    backtracing(n,k,&res,&path,1)
    return res
}

func backtracing(n int,k int,res *[][]int,path *[]int,startIndex int) {
    if len(*path) == k {
        // 需要添加的是path的副本，注意如下添加副本技巧
        *res = append(*res,append([]int(nil),*path...))
        return
    }
    for i := startIndex;i <= n;i++ {
        *path = append(*path,i)
        backtracing(n,k,res,path,i + 1)
        *path = (*path)[0:len(*path) - 1] // 回溯，撤销结果
    }
}

时间复杂度: $O(n\ast 2^n)$
空间复杂度: $O(n)$

还记得我们在回溯算法理论基础中给出的回溯法模板么？

如下：

func backtracking(参数) {
    if 终止条件 {
        存放结果
        return
    }

    for 选择：本层集合中元素（树中节点孩子的数量就是集合的大小） {
        处理节点;
        backtracking(路径，下一层的选择列表) // 递归
        回溯，撤销处理结果
    }
}

对比一下本题的代码，是不是发现有点像！ 所以有了这个模板，就有解题的大体方向，不至于毫无头绪。

总结

组合问题是回溯法解决的经典问题，我们开始的时候给大家列举一个很形象的例子，就是n为100，k为50的话，直接想法就需要50层for循环。

从而引出了回溯法就是解决这种k层for循环嵌套的问题。

然后进一步把回溯法的搜索过程抽象为树形结构，可以直观的看出搜索的过程。

接着用回溯法三部曲，逐步分析了函数参数、终止条件和单层搜索的过程。

剪枝优化

我们说过，回溯法虽然是暴力搜索，但也有时候可以有点剪枝优化一下的。

在遍历的过程中有如下代码：

for i := startIndex;i <= n;i++ {
    *path = append(*path,i)
    backtracing(n,k,res,path,i + 1)
    *path = (*path)[0:len(*path) - 1] 
}

这个遍历的范围是可以剪枝优化的，怎么优化呢？

来举一个例子，n = 4，k = 4的话，那么第一层for循环的时候，从元素2开始的遍历都没有意义了。 在第二层for循环，从元素3开始的遍历都没有意义了。

这么说有点抽象，如图所示：

图中每一个节点（图中为矩形），就代表本层的一轮for循环，那么每一层的for循环从第二个数开始遍历的话，都没有意义，都是无效遍历，因为剩下的全部数都选上，最终也达不到4个数了。

所以，可以剪枝的地方就在递归中每一层的for循环所选择的起始位置。

如果for循环选择的起始位置之后的元素个数 【已经不足】 我们需要的元素个数了，那么就没有必要搜索了。

注意代码中i，就是for循环里选择的起始位置。

for i := startIndex; i <= n; i++ {}

接下来看一下优化过程如下：

已经选择的元素个数：len(*path)

还需要的元素个数为: k - len(*path)

因此在集合n中至多可以从该起始位置 : n - (k - path.size()) + 1，开始遍历，起点从这之后开始遍历的，即使取完剩下的所有数，个数也是不足的。

为什么有个+1呢，因为包括起始位置，我们要是一个左闭的集合。

举个例子，n = 4，k = 3， 目前已经选取的元素为0（len(*path)为0），n - (k - 0) + 1 即 4 - ( 3 - 0) + 1 = 2。

从2开始搜索都是合理的，可以是组合[2, 3, 4]。

这里大家想不懂的话，建议也举一个例子，就知道是不是要+1了。

实际也可以是这个公式推导理解：n - i + 1 < k - len(*path)，等式右边表示还需要选几个数，左边还可以选的数字数量。移位后即变为：i > n + 1 - (k - len(*path))时，数量肯定不足，可以剪枝。

所以优化之后的for循环是：

// i为本次搜索的起始位置
for i := startIndex;i <= n - (k - len(*path)) + 1;i++ {}

优化后整体代码如下：

func combine(n int, k int) [][]int {
    res := make([][]int,0)
    path := make([]int,0)
    backtracing(n,k,&res,&path,1)
    return res
}

func backtracing(n int,k int,res *[][]int,path *[]int,startIndex int) {
    if len(*path) == k {
        // 需要添加的是path的副本，注意如下添加副本技巧
        *res = append(*res,append([]int(nil),*path...))
        return
    }
    for i := startIndex;i <= n - (k - len(*path)) + 1;i++ {
        *path = append(*path,i)
        backtracing(n,k,res,path,i + 1)
        *path = (*path)[0:len(*path) - 1] // 回溯，撤销结果
    }
}

剪枝总结

本篇我们对求组合问题的回溯法代码做了剪枝优化，这个优化如果不画图的话，其实不好理解，也不好讲清楚。

所以我依然是把整个回溯过程抽象为一棵树形结构，然后可以直观的看出，剪枝究竟是剪的哪里。