代码随想录算法训练营第24天 || 理论基础 || 77. 组合

代码随想录算法训练营第24天 || 理论基础 || 77. 组合

理论基础

• 回溯法是什么？

  • 回溯法是一种搜索方式，回溯函数也就是递归函数

  • 回溯法的本质是穷举，效率不高

• 回溯法解决的问题

  • 组合问题
  • 切割问题
  • 子集问题
  • 排列问题
  • 棋盘问题

• 理解回溯法

  • 回溯问题都可以抽象为树结构
  • 回溯法就是在集合地贵重找子集，集合的大小<—>树的宽度，递归的深度<—>树的宽度
  • 递归要有终止条件，才能得到一棵N叉树

回溯法模板

• 回溯三部曲
  • 回溯模板返回值及其参数
    • 返回值一般为void
    • 参数，写完逻辑再确定
  • 回溯终止条件
  • 回溯搜索的遍历过程：
    • 集合的大小对于树的宽度，递归的深度对应树的深度

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

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
    //for循环可以理解是横向遍历，backtracking（递归）就是纵向遍历
}

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]]

个人思路：

模仿给定的模板，确定自己的回溯三部曲

• 确定参数和返回值

  • k和index在每层会改变，k表示还要找几个数，index标记左区间，n不变为右区间

• 确定回溯结束条件

  • 当k == 0时，表示数字已经找够了，此时只需要保存一下结果即可
  • 当 index > n时，表示左区间已经大于右区间，条件不符直接退出

• 回溯搜索逻辑

  • 从左区间开始遍历，加入当前数然后去递归，直到撞上结束条件，递归回来还要经过回溯

    for (int i = index; i <= n; i++) {
        list.add(i);
        backtracking(n, k - 1,  i+1);
        list.remove(list.size() - 1);
    }
    

代码：

class Solution {
    public List<Integer> list = new ArrayList<>();
    public List<List<Integer>> result = new ArrayList<>();

    public List<List<Integer>> combine(int n, int k) {
        backtracking(n, k, 1);
        return result;
    }

    public void backtracking(int n, int k, int index) {
        //找够n个数
        if (k <= 0) {
            result.add(new ArrayList<>(list));
            return;
        }
        //这条路走不通了
        if (index > n)
            return;

        for (int i = index; i <= n; i++) {
            list.add(i);
            backtracking(n, k - 1, i + 1);
            list.remove(list.size() - 1);
        }
    }
}

题解解析：

大体思路代码和上面的差不多，但是讲解上要清晰不少。

小区别：

• if (index > n) return;代码多余，因为下面也进不了循环
• 终止条件不一样，题解用的是list数组的长度判断

其实，当前代码还可以通过剪枝进行优化。

我们发现，许多遍历是没有意义的，它最终也达不到目标的数量，所以就没必要进入递归过程。

如图，我们要做的就是终止无意义的递归遍历

我们可以考虑再单层搜索的逻辑中修改代码[对应箭头起点]，(当然在递归中止部分修改也行[对应图中箭头末尾部位])

对比原代码 for (int i = index; i <= n; i++) { ，不难发现，其实就是调整for循环的右区间为某个值即可

我们可以列方程 剩下的个数 == n - x + 1 >= k - list.size() == 还需要的个数，可得 x <= n - k + list.size() + 1

故可得以下代码：

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> combine(int n, int k) {
        combineHelper(n, k, 1);
        return result;
    }

    /**
     * 每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围，就是要靠startIndex
     * @param startIndex 用来记录本层递归的中，集合从哪里开始遍历（集合就是[1,...,n] ）。
     */
    private void combineHelper(int n, int k, int startIndex){
        //终止条件
        if (path.size() == k){
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = startIndex; i <= n - (k - path.size()) + 1; i++){
            path.add(i);
            combineHelper(n, k, i + 1);
            path.removeLast();
        }
    }
}