LeetCode刷题实战77：组合

算法的重要性，我就不多说了吧，想去大厂，就必须要经过基础知识和业务逻辑面试+算法面试。所以，为了提高大家的算法能力，这个公众号后续每天带大家做一道算法题，题目就从LeetCode上面选！

今天和大家聊的问题叫做组合，我们先来看题面：

https://leetcode-cn.com/problems/combinations/

Given two integers n and k, return all possible combinations of k numbers out of 1 ... n.

You may return the answer in any order.

题意

给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。

样例

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

解题

https://www.cnblogs.com/techflow/p/13139689.html

递归

这是一个全组合问题，实际上我们之前做过全排列问题。我们来分析一下排列和组合的区别，可能很多人知道这两者的区别，但是对于区别本身的理解和认识不是非常深刻。

排列和组合有一个巨大的区别在于， 排列会考虑物体摆放的顺序。也就是说同样的元素构成，只要这些元素一些交换顺序，那么就会被视为是不同的排列。然而对于组合来说，是 不会考虑物体的摆放顺序的。只要是这些元素构成，无论它们怎么调换摆放顺序，都是同一种组合。

我们获取全排列的时候用的是 回溯法，我们当然也可以用回溯法来获取组合。但问题是，我们怎么保证获取到的组合都是元素的组成不同，而不是元素之间的顺序不同呢？

为了保证这一点，需要用到一个惯用的小套路，就是 通过下标递增来控制拿取元素的顺序。如果我们限定了拿取元素的下标是递增的，那么就可以保证每一次拿取到的组合都是独一无二的。所以我们就把这一点加在回溯法上即可，只要理解了，并不难实现。

在代码的实现当中，我们用上了闭包，省略了几个参数的传递，整体上来说编码的难度降低了一些。


     
     class Solution:
 
      
      
    
 
      
      def combine(self, n: int, k: int) -> List[List[int]]:
 
      
      
        
 
      
      def dfs(start, cur):
 
      
      
            
 
      
      # 如果当前已经拿到了K个数的组合，直接加入答案
 
      
      
            
 
      
      # 注意要做深拷贝，否则在之后的回溯过程当中变动也会影响结果
 
      
      
            
 
      
      if len(cur) == k:
 
      
      
                ret.append(cur[:])
 
      
      
                
 
      
      return
 
      
      
            
 
      
      
            
 
      
      # 从start+1的位置开始遍历
 
      
      
            
 
      
      for i 
 
      
      in range(start+
 
      
      1, n):
 
      
      
                cur.append(i+
 
      
      1)
 
      
      
                dfs(i, cur)
 
      
      
                
 
      
      # 回溯
 
      
      
                cur.pop()
 
      
      
                
 
      
      
        ret = []
 
      
      
        dfs(
 
      
      -1, [])
 
      
      
        
 
      
      return ret

迭代

这题并不是只有一种做法，我们也可以不用递归实现算法。不用递归意味着没有系统帮助我们建栈存储中间信息了，需要我们自己把迭代过程当中所有变量的关系整理清楚。

我们假设n=8，k=3，那么在所有合法的组合当中，最小的组合一定是[1,2,3]，最大的组合一定是[6,7,8]。如果我们保证组合当中的元素是有序排列的，那么组合之间的大小关系也是可以确定的。进而我们可以思考 设计一种方案，使得我们可以从最小的组合[1,2,3]一直迭代到[6,7,8]，并且我们还要保证在迭代的过程当中，组合当中元素的顺序不会被打乱。

我们可以想象成这n个数在一根“直尺”上排成了一行，我们有k个滑动框在上面移动。这k个滑动框取值的结果就是n个元素中选取k个的组合，并且由于滑动框之间是不能交错的，所以保证了这k个值是有序的。我们要做的就是设计一种 移动滑动框的算法，使得能够找到所有的组合情况。

我们可以想象一下，一开始的时候滑动框都聚集在最左边，我们要移动只能移动最右侧的滑动框。我们把滑动框从k移动到了k+1，那么这个时候它的右侧有k-1个滑动框，一共有k个位置。

那么这个问题其实转化成了k个元素当中取k-1个组合的子问题。我们把1-k的这个部分看成是新的“直尺”，我们要在其中移动k-1个滑动框获取所有的组合。首先，我们需要把这k-1个滑动框全部移动到左侧，然后再移动其中最右侧的滑动框。然后循环往复，直到所有的滑动框都往右移动了一格为止，这其实是一个递归的过程。

我们不去深究这个递归的整个过程，我们只需要 理解清楚其中的几个关键点就可以了。首先，对于每一次递归来说，我们 只会移动这个递归范围内最右侧的滑动框，其次我们清楚每一次递归过程中的起始状态。开始状态就是所有的滑动框全部集中在“直尺”的最左侧，结束状态就是全部集中在最右侧。

我们把上面的逻辑整理一下，假设我们经过一系列操作之后，m个滑动框全部移动到了长度为n的直尺的最右侧。这就相当于

的组合都已经获取完了。如果n+1的位置还有滑动框，并且它的右侧还可以移动，那么我们需要将它往右移动一个，到n+2的位置。这个时候剩下的局面就是

，为了获取这些组合，我们 需要把这m个滑动框全部再移动到直尺的最左侧，重新开始移动。

我们在实现的时候当然没有滑动框，我们可以用一个数组记录滑动框当中的元素。

我先用递归写一下这段逻辑：


     
     
      
      
 class Solution:
 
      
      
    def combine(self, n: 
 
      
      int, 
 
      
      k: 
 
      
      int) -> List[List[
 
      
      int]]:
 
      
      
        def comb(window, 
 
      
      m, 
 
      
      ret):
 
      
      
            
 
      
      ret.
 
      
      append(window[:-
 
      
      1])
 
      
      

            # 如果第
 
      
      m位的滑动框不超过直尺的范围并且
 
      
      m右侧的滑动框
 
      
      
            
 
      
      while window[
 
      
      m] < 
 
      
      min(n - 
 
      
      k + 
 
      
      m + 
 
      
      1, window[
 
      
      m+
 
      
      1] - 
 
      
      1):
 
      
      
                # 向右滑动一位
 
      
      
                window[
 
      
      m] += 
 
      
      1
 
      
      
                # 如果
 
      
      m左侧还有滑动框，递归
 
      
      
                
 
      
      if 
 
      
      m > 
 
      
      0:
 
      
      
                    # 把左侧的滑动框全部移动到最左侧
 
      
      
                    window[:
 
      
      m] = 
 
      
      range(
 
      
      1, 
 
      
      m+
 
      
      1)
 
      
      
                    comb(window, 
 
      
      m-
 
      
      1, 
 
      
      ret)
 
      
      
                
 
      
      else:
 
      
      
                    # 否则记录答案
 
      
      
                    
 
      
      ret.
 
      
      append(window[:-
 
      
      1])
 
      
      

                
 
      
      
        
 
      
      ret = []
 
      
      
        window = 
 
      
      list(
 
      
      range(
 
      
      1, 
 
      
      k+
 
      
      1))
 
      
      
        # 额外多放一个滑动框作为标兵
 
      
      
        window.
 
      
      append(n+
 
      
      1)
 
      
      
        comb(window, 
 
      
      k-
 
      
      1, 
 
      
      ret)
 
      
      
        
 
      
      return 
 
      
      ret

这种解法的速度比上面正规递归的速度快了许多，因为我们递归的过程当中做了诸多限制， 剪掉了很多无关的情况，相当于做了极致的剪枝。

最关键的是上面的这段逻辑我们是可以用循环实现的，所以我们可以用循环来将递归的逻辑展开，就得到了下面这段代码。


     
     class Solution:
 
      
      
    
 
      
      def combine(self, n: int, k: int) -> List[List[int]]:
 
      
      
        
 
      
      # 构造滑动框
 
      
      
        window = list(range(
 
      
      1, k + 
 
      
      1)) + [n + 
 
      
      1]
 
      
      
        
 
      
      
        ret, j = [], 
 
      
      0
 
      
      

        
 
      
      while j < 
 
      
      k:
 
      
      
            
 
      
      # 添加答案
 
      
      
            ret.append(window[
 
      
      :k])
 
      
      

            j = 
 
      
      0
 
      
      
            
 
      
      # 从最左侧的滑动框开始判断
 
      
      
            
 
      
      # 如果滑动框与它右侧滑动框挨着，那么就将它移动到最左侧
 
      
      
            
 
      
      # 因为它右侧的滑动框一定会向右移动
 
      
      
            
 
      
      while j < k 
 
      
      and window[j + 
 
      
      1] == window[j] + 
 
      
      1:
 
      
      
                window[j] = j + 
 
      
      1
 
      
      
                j += 
 
      
      1
 
      
      
            
 
      
      # 连续挨着最右侧的滑动框向右移动一格
 
      
      
            window[j] += 
 
      
      1
 
      
      
            
 
      
      
        
 
      
      return ret

这段代码虽然非常精炼，但是 很难理解，尤其是你没能理解上面递归实现的话，会更难理解。所以我建议，先把递归实现的滑动框的方法理解了，再来理解不含递归的这段，会容易一些。

总结

我们通过回溯法求解组合的方法应该是最简单也是最基础的，难度也不大。相比之下后面一种方法则要困难许多，我们直接去啃，往往不得要领。既会疑惑为什么这样可以保证能获得所有的组合，又会不明白其中具体的实现逻辑。所以如果想要弄明白第二种方法， 一定要从滑动框这个模型出发。

从代码实现的角度来说，滑动框方法的递归解法比非递归的解法还要困难。因为递归条件以及逻辑都比较复杂，还涉及到存储答案的问题。但是 从理解上来说，递归的解法更加容易理解一些，非递归的算法往往会疑惑于j这个指针的取值。所以如果想要理解算法的话，可以从递归的代码入手，想要实现代码的话，可以从非递归的方法入手。

这道题目非常有意思，值得大家细细思考。

好了，今天的文章就到这里，如果觉得有所收获，请顺手点个在看或者转发吧，你们的支持是我最大的动力。

上期推文：

LeetCode40-60题汇总，速度收藏！

LeetCode刷题实战61：旋转链表

LeetCode刷题实战62：不同路径

LeetCode刷题实战63：不同路径 II

LeetCode刷题实战64：最小路径和

LeetCode刷题实战66：加一

LeetCode刷题实战67：二进制求和

LeetCode刷题实战68：文本左右对齐

LeetCode刷题实战69：x 的平方根