算法力扣刷题记录六十三【回溯章节开篇】

news2024/9/27 21:20:20

前言

开始回溯章节学习。

在二叉树中预先体会了回溯。那么回溯单独来说是怎么回事？

一、基础知识学习

回溯基础知识参考链接

在这里插入图片描述

二、组合问题

2.1题目阅读

给定两个整数 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

2.2尝试实现

思路

题目就是组合，解决组合问题想到回溯算法。穷举每一个选项。
确定该集合的树形结构：以示例一为例——如下图：
利用回溯模版开始填充逻辑——

确定函数的返回值：void。用vector<vector > result放结果，所以无需返回值，直接搜集。
确定函数参数：
- int n用来限定一个树的横向范围；
- int k 终止条件需要。当中间vector< int > temp.size() == k，放入result中；
- int num，当前层从num开始循环。如图红色线的一条递归路径：第一层从1开始；第二层从2开始；第三层从3开始；第四层从4开始。结合n确定本层有几个孩子。
- vector< int >& temp放中间结果，引用形式；
- vector<vector > result主函数的返回值，引用形式；
确定终止条件：在分析参数int k时，已经指出终止条件：vector< int > temp.size() == k。终止逻辑：result.push_back(temp);
中间的逻辑：
- for循环的起始终止：i = num+1;i <= n;i++ 。以第一个树来说：第一层的孩子：2,3,4；第二层节点2的孩子：3,4；第三次节点3的孩子：4.
- 调用本回溯（递归）函数；
- temp.pop_back()；回溯操作，删除下一层加入temp的元素。

递归函数完成之后，发现主函数中也需要for循环替换下一个树。

（对照代码）

代码实现

class Solution {
public:
    void backtracking(int n,int k,int num,vector<int>& temp,vector<vector<int>>& result){
        temp.push_back(num);//放入该层节点
        if(temp.size() == k){
            result.push_back(temp);//搜集结果
            return;
        }
        
        for(int i = num+1;i <= n;i++){
            //处理孩子
            backtracking(n,k,i,temp,result);
            temp.pop_back();//回溯，弹出下一层放入的元素
        }
        return;
    }
    vector<vector<int>> combine(int n, int k) {
        vector<vector<int>> result;
        vector<int> temp;
        for(int i=1;i <= n;i++){
            backtracking(n,k,i,temp,result);
            temp.clear();//第一层的清空。
        }
        return result;
    }
};

所以，本代码的第一层是在主函数中控制。第二层之后在递归（回溯）函数中实现。

体会回溯

回溯其实不是一个函数，整个函数不是只完成回溯，回溯其实是一个操作：temp.pop_back();只这一行是回溯。

整个函数是一个递归，但是递归当前层中有for循环，从下层回归到本层进行回溯操作。

2.3 参考学习

参考学习链接

参考给的思路：按照一、基础知识学习的递归模版完成。抽象成一个树的结构。参考给的树：
所以2.2尝试实现和参考的区别：第一层直接在递归函数中完成，主函数中没有for循环控制第一层。
参考代码实现：（在2.2尝试实现上改进）

class Solution {
public:
    void backtracking(int n,int k,int num,vector<int>& temp,vector<vector<int>>& result){
        //终止条件：当temp中间结果个数等于目标组合个数，放入最终结果集中
        if(temp.size() == k){
            result.push_back(temp);//搜集结果
            return;
        }
        //num就是参考中的startindex
        for(int i = num;i <= n;i++){//从num开始。
            temp.push_back(i);//放入本层元素。
            //处理孩子，深入递归
            backtracking(n,k,i+1,temp,result);//递的时候给i+1
            temp.pop_back();//归的时候回溯，弹出下一层放入的元素
        }
        return;
    }
    vector<vector<int>> combine(int n, int k) {
        vector<vector<int>> result;
        vector<int> temp;
        backtracking(n,k,1,temp,result);
        return result;
    }
};

剪枝优化：怎么剪？如何剪？剪枝优化参考讲解。
但为什么for循环的终止条件是n-(k-path.size())+1的规律再展现一遍。

解释n-(k-path.size())+1是for的终止条件：
- 集合个数n说明完整的树结构有n层；
- k-path.size()代表组合temp中现在还缺多少个元素；注意本层元素添加是在for循环内部，此时还没有加入本次元素。
- n-(k-path.size())+1代表能抵达第k层的路径范围。集合总数n减去后面(k-path.size())个元素，前面剩下的是已经选择的路径。再加1是因为这个路径选择能抵达k。（看下图红色文本栏对数组颜色的区分）。

剪枝优化的代码：把for循环的终止条件改了，缩小for循环的终止范围。

class Solution {
public:
    void backtracking(int n,int k,int num,vector<int>& temp,vector<vector<int>>& result){
        //终止条件：当temp中间结果个数等于目标组合个数，放入最终结果集中
        if(temp.size() == k){
            result.push_back(temp);//搜集结果
            return;
        }
        //num就是参考中的startindex
        for(int i = num;i <= n-(k-temp.size())+1;i++){//从num开始。
            temp.push_back(i);//放入本层元素。
            //处理孩子，深入递归
            backtracking(n,k,i+1,temp,result);//递的时候给i+1
            temp.pop_back();//归的时候回溯，弹出下一层放入的元素
        }
        return;
    }
    vector<vector<int>> combine(int n, int k) {
        vector<vector<int>> result;
        vector<int> temp;
        backtracking(n,k,1,temp,result);
        return result;
    }
};