代码随想录 - 训练营8期- day 29

最新推荐文章于 2024-10-05 20:01:36 发布

薇薇拉

最新推荐文章于 2024-10-05 20:01:36 发布

阅读量77

点赞数

文章标签：数据结构算法 leetcode c++ Powered by 金山文档

本文链接：https://blog.csdn.net/RossQAQ/article/details/129330751

版权

文章介绍了如何使用回溯法解决三种数列问题：递增子序列、全排列以及全排列II。每个问题都通过定义一个BackTracking函数，利用used数组或layUsed数组来避免重复，并确保在每一步中找到有效的解。对于有重复元素的情况，如全排列II，需要额外处理重复项的去重逻辑。

摘要由CSDN通过智能技术生成

491.递增子序列
46.全排列
47.全排列 II

491. 递增子序列

这个题去重和前面也有点不一样

使用一个 used 数组，记录本层使用过的元素

class Solution {
    vector<vector<int>> res;
    vector<int> path;
    void BackTracking(vector<int>& nums, int idx) {
        if(path.size() > 1) {
            res.push_back(path);
        }
        bool used[201] {};
        for(int i = idx; i < nums.size(); ++i) {
            if( ( !path.empty() && nums[i] < path.back() ) || (used[nums[i] + 100] == true )) {
                continue;
            }
            used[nums[i] + 100] = true;
            path.push_back(nums[i]);
            BackTracking(nums, i + 1);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        BackTracking(nums, 0);
        return res;
    }
};

46. 全排列

这个题每次都从头开始搜索就可以，利用used数组在每一枝上去重

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

47. 全排列II

跟上一题的区别是本题有重复元素

想想491的去重

class Solution {
    vector<vector<int>> res;
    vector<int> path;
    void BackTracking(vector<int>& nums, vector<int>& used) {
        if(path.size() == nums.size()) {
            res.push_back(path);
            return;
        }
        bool layUsed[21] {};
        for(int i = 0; i < nums.size(); ++i) {
            if(used[i] || layUsed[nums[i] + 10] == true) {
                continue;
            }
            layUsed[nums[i] + 10] = true;
            used[i] = true;
            path.push_back(nums[i]);
            BackTracking(nums, used);
            used[i] = false;
            path.pop_back();
            
        }
    }
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<int> used(nums.size(), 0);
        BackTracking(nums, used);
        return res;
    }
};