Leetcode : combinations ( 组合 77 )

本文的目的是收集一些典型的题目，记录其题型与解法，理解其思想，即做到一通百通！
欢迎大家提出宝贵意见！

combinations ( 组合 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

题解

解法一

递归回溯实现 组合型枚举
重点概括：

• 如果解决一个问题有多个步骤，每一个步骤有多种方法，题目又要我们找出所有的方法，可以使用回溯算法；
• 回溯算法是在一棵树上的 深度优先遍历；
• 组合问题，相对于排列问题而言，不计较一个组合内元素的顺序性（即 [1, 2, 3] 与 [1, 3, 2] 认为是同一个组合），因此很多时候需要按某种顺序展开搜索，这样才能做到不重不漏。

树形问题上的 深度优先遍历，因此可以首先画出树形结构。例如输入：n = 4, k = 2，可以发现如下递归结构：

• 如果组合里有 1 ，那么需要在 [2, 3, 4] 里再找 11 个数；
• 如果组合里有 2 ，那么需要在 [3, 4] 里再找 11数。
  注意：这里不能再考虑 11，因为包含 11 的组合，在第 1 种情况中已经包含， 所以在回溯时应从当前位置开始递归， 不应从开始位置递归。

public List<List<Integer>> combine(int n, int k) {
    List<List<Integer>> res = new ArrayList<>();
    if (k <= 0 || n < k) {
        return res;
    }
    // 从 1 开始是题目的设定
    Deque<Integer> path = new ArrayDeque<>();
    dfs(n, k, 1, path, res);
    return res;
}

// 进行 深度优先遍历
private void dfs(int n, int k, int begin, Deque<Integer> path, List<List<Integer>> res) {
    // 递归终止条件是：path 的长度等于 k， 即找到所需的一种答案
    if (path.size() == k) {
        res.add(new ArrayList<>(path));
        return;
    }

    // 遍历可能的搜索起点
    for (int i = begin; i <= n; i++) {
        // 向路径变量里添加一个数
        path.addLast(i);
        // 下一轮搜索，设置的搜索起点要加 1，因为组合数理不允许出现重复的元素
        dfs(n, k, i + 1, path, res);
        // 重点理解这里：深度优先遍历有回头的过程，因此递归之前做了什么，递归之后需要做相同操作的逆向操作
        path.removeLast();
    }
}

说明：

• 叶子结点的价值体现在从根结点到叶子结点的路径上，因此需要一个表示路径的变量 path，它是一个列表，特别地，path 是一个栈
• 每一个结点递归地在做同样的事情，区别在于搜索起点，因此需要一个变量 start，表示在区间 [begin, n]里选出若干个数的组合，这样才不会造成重复的组合！

以下代码可以帮助读者更好的理解回溯在组合上的应用：

class Solution {
    List<Integer> temp = new ArrayList<Integer>();
    List<List<Integer>> ans = new ArrayList<List<Integer>>();
    
    public List<List<Integer>> combine(int n, int k) {
        dfs(1, n, k);
        return ans;
    }

    public void dfs(int cur, int n, int k) {
        // 剪枝：temp 长度加上区间 [cur, n] 的长度小于 k，不可能构造出长度为 k 的 temp
        if (temp.size() + (n - cur + 1) < k) {
            return;
        }
        // 记录合法的答案
        if (temp.size() == k) {
            ans.add(new ArrayList<Integer>(temp));
            return;
        }
        // 考虑选择当前位置时，已经选择好了一个数
        // 进行递归选择第二个数
        temp.add(cur);
        dfs(cur + 1, n, k);
        // 移除选择好的上一个数
        temp.remove(temp.size() - 1);
        // 考虑不选择当前位置
        // 直到 递归到 选好的数加上未选好的数小于 k 时退出！
        dfs(cur + 1, n, k);
    }
}