代码随想录100——回溯算法11——子集3——递增子序列

Ethan Yankang

已于 2024-07-19 19:26:57 修改

阅读量898

点赞数 22

文章标签：开发语言 java 算法

于 2024-07-19 19:25:59 首次发布

本文链接：https://blog.csdn.net/m0_68657832/article/details/140504279

版权

🌈hello，你好鸭，我是Ethan，西安电子科技大学大三在读，很高兴你能来阅读。

✔️目前博客主要更新Java系列、项目案例、计算机必学四件套等。
🏃人生之义，在于追求，不在成败，勤通大道。加油呀！

🔥个人主页：Ethan Yankang
🔥推荐：史上最强八股文 || 一分钟看完我的上千篇博客

🔥温馨提示：划到文末发现专栏彩蛋点击这里直接传送

🔥本篇概览：数据结构与算法 || 详细讲解了回溯算法中的子集问题——递增子序列。🌈⭕🔥

【计算机领域一切迷惑的源头都是基本概念的模糊，算法除外】

🌈序言

算法乃我长久之志也，此关必过。今日得此代码随想录之良品辅助，应按此路学之习之，而长久不可懈怠。

前一系列文章详细讲解了利用回溯算法求解子集的问题，建议先将这部分知识掌握之后再来学习本篇内容，点击查看。

🔥前一篇章： 代码随想录99——回溯算法10——子集2——子集II-CSDN博客

🔥 代码随想录系列所有算法精讲一键查阅

🌈引出

和子集问题有点像，但又处处是陷阱

题目：491.递增子序列

力扣题目链接(opens new window)

给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。

示例:

输入: [4, 6, 7, 7]
输出: [[4, 6], [4, 7], [4, 6, 7], [4, 6, 7, 7], [6, 7], [6, 7, 7], [7,7], [4,7,7]]

说明:

给定数组的长度不会超过15。
数组中的整数范围是 [-100,100]。
给定数组中可能包含重复数字，相等的数字应该被视为递增的一种情况。

剖析题干重点：

注意这里是序列，就不能排序。

🔥思路分析：

这个递增子序列比较像是取有序的子集。而且本题也要求不能有相同的递增子序列。

这又是子集，又是去重，是不是不由自主的想起了刚刚讲过的90.子集II (opens new window)。

就是因为太像了，更要注意差别所在，要不就掉坑里了！

在90.子集II (opens new window)中我们是通过排序，再加一个标记数组来达到去重的目的。

而本题求自增子序列，是不能对原数组进行排序的(之前的数组哈希表是用来做去重的，但是要排序，而哈希表共有三种实现方式——数组、set、map。这里只能使用后面两种方式。这里结合了之前的hash表的知识。是一道好题目。)，排完序的数组都是自增子序列了。

所以不能使用之前的去重逻辑！

本题给出的示例，还是一个有序数组 [4, 6, 7, 7]，这更容易误导大家按照排序的思路去做了。

为了有鲜明的对比，我用[4, 7, 6, 7]这个数组来举例，抽象为树形结构如图：

回溯三部曲

递归函数参数

本题求子序列，很明显一个元素不能重复使用，所以需要startIndex(表示从下一位开始计数，所以用到)，调整下一层递归的起始位置。

代码如下：

vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& nums, int startIndex)

终止条件

本题其实类似求子集问题，也是要遍历树形结构找每一个节点，所以和回溯算法：求子集问题！ (opens new window)一样，可以不加终止条件，startIndex每次都会加1，并不会无限递归。

但本题收集结果有所不同，题目要求递增子序列大小至少为2，所以代码如下：

if (path.size() > 1) {
    result.push_back(path);
    // 注意这里不要加return，因为要取树上的所有节点
}

单层搜索逻辑

在图中可以看出，同一父节点下的同层上使用过的元素就不能再使用了

那么单层搜索代码如下：

unordered_set<int> uset; // 使用set来对本层元素进行去重
for (int i = startIndex; i < nums.size(); i++) {
    if ((!path.empty() && nums[i] < path.back())
            || uset.find(nums[i]) != uset.end()) {
            continue;
    }
    uset.insert(nums[i]); // 记录这个元素在本层用过了，本层后面不能再用了
    path.push_back(nums[i]);
    backtracking(nums, i + 1);
    path.pop_back();
}

最后整体C++代码如下：

// 版本一
class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex) {
        if (path.size() > 1) {
            result.push_back(path);
            // 注意这里不要加return，要取树上的节点
        }
        unordered_set<int> uset; // 使用set对本层元素进行去重
        for (int i = startIndex; i < nums.size(); i++) {
            if ((!path.empty() && nums[i] < path.back())
                    || uset.find(nums[i]) != uset.end()) {
                    continue;
            }
            uset.insert(nums[i]); // 记录这个元素在本层用过了，本层后面不能再用了
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        result.clear();
        path.clear();
        backtracking(nums, 0);
        return result;
    }
};

优化

以上代码用我用了unordered_set<int>来记录本层元素是否重复使用。

其实用数组来做哈希，效率就高了很多。

注意题目中说了，数值范围[-100,100]，所以完全可以用数组来做哈希。

程序运行的时候对unordered_set 频繁的insert，unordered_set需要做哈希映射（也就是把key通过hash function映射为唯一的哈希值）相对费时间，而且每次重新定义set，insert的时候其底层的符号表也要做相应的扩充，也是费事的。

那么优化后的代码如下：

// 版本二
class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex) {
        if (path.size() > 1) {
            result.push_back(path);
        }
        int used[201] = {0}; // 这里使用数组来进行去重操作，题目说数值范围[-100, 100]
        for (int i = startIndex; i < nums.size(); i++) {
            if ((!path.empty() && nums[i] < path.back())
                    || used[nums[i] + 100] == 1) {
                    continue;
            }
            used[nums[i] + 100] = 1; // 记录这个元素在本层用过了，本层后面不能再用了
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        result.clear();
        path.clear();
        backtracking(nums, 0);
        return result;
    }
};

这份代码在leetcode上提交，要比版本一耗时要好的多。

所以正如在哈希表：总结篇！（每逢总结必经典） (opens new window)中说的那样，数组，set，map都可以做哈希表，而且数组干的活，map和set都能干，但如果数值范围小的话能用数组尽量用数组。

又忘了，的抓紧往前复习了！！

🌈最终代码：

不用map，使用set来去重

利用LinkedList效率更好。

class Solution {
    List<List<Integer>> result = new LinkedList<>();
    List<Integer> path = new LinkedList<>();
    public List<List<Integer>> findSubsequences(int[] nums) {
        backTracking(nums, 0);
        return result;
    }
    private void backTracking(int[] nums, int startIndex){
        if(path.size() >= 2)
                result.add(new LinkedList<>(path));            
        HashSet<Integer> hs = new HashSet<>();
        for(int i = startIndex; i < nums.length; i++){
            if(!path.isEmpty() && path.get(path.size() -1 ) > nums[i] || hs.contains(nums[i]))
                continue;

//你要从里面取东西，你就要判定!path.isEmpty() ，否则就会报错
//这里使用hs.contains(nums[i])就确保里面一个数只能出现一次，这确保了去重效果

            hs.add(nums[i]);
            path.add(nums[i]);
            backTracking(nums, i + 1);
            path.removeLast();
        }
    }
}

使用map，更快

//法二：使用map
class Solution {
    //结果集合
    List<List<Integer>> res = new ArrayList<>();
    //路径集合
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> findSubsequences(int[] nums) {
        getSubsequences(nums,0);
        return res;
    }
    private void getSubsequences( int[] nums, int start ) {
        if(path.size()>1 ){
            res.add( new ArrayList<>(path) );
            // 注意这里不要加return，要取树上的节点
        }

key为值，value为频次
        HashMap<Integer,Integer> map = new HashMap<>();
        for(int i=start ;i < nums.length ;i++){
            if(!path.isEmpty() && nums[i]< path.getLast()){
                continue;
            }
            // 使用过了当前数字
            //这是哈希表中判断值是否出现过的技巧，之前的题目有讲到，请回复
            if ( map.getOrDefault( nums[i],0 ) >=1 ){
                continue;
            }

存放次数,这相当于固定的了，记住好了1
            map.put(nums[i],map.getOrDefault( nums[i],0 )+1);
            path.add( nums[i] );
            getSubsequences( nums,i+1 );
            path.removeLast();
        }
    }
}

今日问题：

🔥今日总结：

1.总结

本题题解清一色都说是深度优先搜索，但我更倾向于说它用回溯法，而且本题我也是完全使用回溯法的逻辑来分析的。

相信大家在本题中处处都能看到是回溯算法：求子集问题（二） (opens new window)的身影，但处处又都是陷阱。

对于养成思维定式或者套模板套嗨了的同学，这道题起到了很好的警醒作用。更重要的是拓展了大家的思路！

2.回溯算法再理解：

回溯算法就是先序遍历（很明显的，因为先从根节点开始的，只有先序遍历是这样）。

再一句自己悟到的——纵向走不下去了，开始走横向。这就是先序遍历。也正是回溯算法的动态灵魂。

3.本题使用set与map去重处理

本题要求自增子序列，是不能对原数组进行排序的(之前的数组做哈希表是用来做去重的，但是要排序，而哈希表共有三种实现方式——数组、set、map。这里只能使用后面两种方式。这里结合了之前的hash表的知识。是一道好题目。)，排完序的数组都是自增子序列了。

所以不能使用之前的去重逻辑！

这意味着之前的也可以用set、map来去重。

4.HashMap重温

1.存放value与频次

存放次数,这相当于固定的了，记住好了1
 map.put(nums[i],map.getOrDefault( nums[i],0 )+1);

2.设置键的初始值的好用法，没有的话就是默认的0.

map.getOrDefault(nums[i],0)>=1

从 map 中获取键为 nums[i] 的值，如果该键不存在，则返回默认值 0 。然后将获取到的值与 1 进行比较，判断其是否大于或等于 1 。

📣非常感谢你阅读到这里，如果这篇文章对你有帮助，希望能留下你的点赞👍 关注❤收藏✅ 评论💬，大佬三连必回哦！thanks！！！
📚愿大家都能学有所得，功不唐捐！

👇下面是专栏彩蛋系列，你会喜欢的！（为了避免影响算法的简洁与优美，这里直接将之前的几十个专栏简化为3个部分，不过你点击开后发现惊喜。）👇

💖💖💖💖💖💖💖💖💖💖💖💖💖💖💖💖💖💖

热门专栏

🌈🌈专栏彩蛋系列

🌈🌈史上最全八股文，欢迎收藏

🌈🌈一篇文章了解我的上千篇博客