代码随想录算法训练营day29

最新推荐文章于 2024-09-14 22:25:23 发布

Mitakiyuki

最新推荐文章于 2024-09-14 22:25:23 发布

阅读量100

点赞数 3

文章标签：算法 leetcode 数据结构

本文链接：https://blog.csdn.net/Mitakiyuki/article/details/137341399

版权

491.递增子序列

思路： 本题要求取得递增子序列，同时数组不能进行排序，也不能有重复元素。此时，就需要使用一个set来记录元素是否重复，在长度大于1的时候放入结果数组。

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void bt(vector<int>& nums,int startindex){
        if(path.size()>1){
            result.push_back(path);
        }
        unordered_set<int> uset;
        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]);
            bt(nums,i+1);
            path.pop_back();
        }
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        bt(nums,0);
        return result;
    }
};

46.全排列

思路： 本题要求对元素进行排列，对元素位置有要求，因此需要使用一个used来记录哪一个元素使用过，剩余的元素依次进入结果数组。在满足结果数组大小时，存入reseult。

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void bt(vector<int>& nums,vector<bool>& used){
        if(path.size()==nums.size()){
            result.push_back(path);
            return;
        }
        for(int i=0;i<nums.size();i++){
            if (used[i] == true) continue;
            path.push_back(nums[i]);
            used[i]=true;
            bt(nums,used);
            path.pop_back();
            used[i]=false;
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        vector<bool> used(nums.size(),false);
        bt(nums,used);
        return result;
    }
};

47.全排列 II

思路： 本题与上一题不同之处在于要求不重复，因此需要进行排序，然后去重。去重的方法与40.组合总和II (opens new window)、90.子集II两题相同。其余部分思路遇上一题相同。

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, vector<bool>& used) {
        if (path.size() == nums.size()) {
            result.push_back(path);
            return;
        }
        for (int i = 0; i < nums.size(); i++) {
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            if (used[i] == false) {
                used[i] = true;
                path.push_back(nums[i]);
                backtracking(nums, used);
                path.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;
    }
};