代码随想录算法训练营第二十二天 | LeetCode491.递增子序列、LeetCode46.全排列、LeetCode47.全排列II-优快云博客

本文链接：https://blog.youkuaiyun.com/zhuabazhuabahuo/article/details/143698058

代码随想录算法训练营第二十二天 | LeetCode491.递增子序列、LeetCode46.全排列、LeetCode47.全排列II

01 总结

ref：回溯总结

回溯就是深度优先搜索！

02-1 LeetCode491.递增子序列

相关资源

题目链接：491. 非递减子序列

文章讲解：LeetCode491.递增子序列

视频讲解：LeetCode：491.递增子序列

题目：

给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

第一想法：子序列很像需要去重的组合问题，但是序列不能给排序啊，这该如何去重呢[4,3,4,5] --> [4,5]

纵向只要是i+1处大于等于i处，则加入rec中；横向其他分支跳过等于startIndex的

每个生成树的叶子节点（如果rec长度大于等于二）都需要记录到result中

实现：错误实现

class Solution {
public:
    vector<int> rec;
    vector<vector<int>> result;
    void backtracking(vector<int>& nums, int startIndex){
        if(rec.size()>=2){
            result.push_back(rec);
        }
        if(startIndex>=nums.size()){
            return;
        }
        for(int i = startIndex; i < nums.size(); i++){
            if(i>startIndex&&nums[i]==nums[startIndex]){
                continue;
            }    
            if(rec.size()==0||(rec.size()>=1&&nums[i]>=rec.back())){
                rec.push_back(nums[i]);
                backtracking(nums,i+1);
                rec.pop_back();
            }
        }
    }

    vector<vector<int>> findSubsequences(vector<int>& nums) {
        backtracking(nums,0);
        return result;
    }
};

遇到的困难：去处树层重复元素不知道咋去，因为是无序的

看完代码随想录之后的想法：这种无法排序的应该使用哈希表（之前的使用used数组的方法也可以用哈希表）

class Solution {
public:
    vector<int> rec;
    vector<vector<int>> result;
    void backtracking(vector<int>& nums, int startIndex){
        if(rec.size()>=2){
            result.push_back(rec);
        }
        if(startIndex>=nums.size()){
            return;
        }
        int used[201]={0};
        for(int i = startIndex; i < nums.size(); i++){
            if((!rec.empty()&&nums[i]<rec.back())||used[nums[i]+100]==1){
                continue;
            }
            used[nums[i]+100] = 1;
            rec.push_back(nums[i]);
            backtracking(nums,i+1);
            rec.pop_back();   
        }
    }

    vector<vector<int>> findSubsequences(vector<int>& nums) {
        backtracking(nums,0);
        return result;
    }
};

ToDo：这是一类需要把树层的重复元素剔除的题目，深入思考并总结一下！

02-2 LeetCode46.全排列

相关资源

题目链接：46. 全排列
文章讲解：LeetCode46.全排列
视频讲解：LeetCode：46.全排列

题目：给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案

第一想法：回溯算法，每层都是从i=0开始，但需要排除掉rec种的元素，考虑到无重复数字，且范围较小，我使用数组来作为哈希表

实现：

class Solution {
public:
    vector<int> rec;
    vector<vector<int>> result;
    int visited[21]={0};
    void backtracking(vector<int>& nums){
        if(rec.size()==nums.size()){
            result.push_back(rec);
            return;
        }
        for(int i = 0; i < nums.size(); i++){
            if(visited[nums[i]+10]==1){
                continue;
            }
            rec.push_back(nums[i]);
            visited[nums[i]+10]=1;
            backtracking(nums);
            visited[nums[i]+10]=0;
            rec.pop_back();
        }
        return;
    }
    vector<vector<int>> permute(vector<int>& nums) {
        backtracking(nums);
        return result;
    }
};

看完代码随想录之后的想法：思路一致，但used[i]更加简洁一点

ToDo：复习

02-3 LeetCode47.全排列II

相关资源

题目链接：47. 全排列 II

文章讲解：LeetCode47.全排列II

视频讲解：LeetCode：47.全排列 II

题目：给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列

第一想法：和带重复数字的组合问题类似，树层上需要对重复元素去重（先排序，然后used数组就可以！），树枝上无需去重，但要用used数组跟踪

实现：

class Solution {
public:
    vector<int> rec;
    vector<vector<int>> result;
    void backtracking(vector<int>& nums, vector<bool>& used){
        if(rec.size()==nums.size()){
            result.push_back(rec);
        }
        for(int i = 0; i < nums.size(); i++){
            if(used[i]||(i>0&&nums[i]==nums[i-1]&&!used[i-1])){
                continue;
            }
            used[i] = true;
            rec.push_back(nums[i]);
            backtracking(nums,used);
            rec.pop_back();
            used[i] = false;
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<bool> used(nums.size(), false);
        backtracking(nums,used);
        return result;
    }
};

看完代码随想录之后的想法：思路一致，但是used[i - 1] == true居然也可以通过

总结：如果要对树层中前一位去重，就用used[i - 1] == false，如果要对树枝前一位去重用used[i - 1] == true。对于排列问题，树层上去重和树枝上去重，都是可以的，但是树层上去重效率更高

ToDo：复习