代码随想录第22天|

最新推荐文章于 2024-10-09 22:28:58 发布

王禄DUT

最新推荐文章于 2024-10-09 22:28:58 发布

阅读量215

点赞数 2

分类专栏：代码随想录文章标签：算法 leetcode 数据结构

本文链接：https://blog.csdn.net/m0_73596392/article/details/142412264

版权

代码随想录专栏收录该内容

32 篇文章 0 订阅

订阅专栏

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    void backtracking(vector<int>& nums,int startIndex){
        if(startIndex>=nums.size())
        {
            if(path.size()>1)
               res.push_back(path);
            return;
        }
        if(path.size()>1)
           res.push_back(path);
        unordered_set<int> used;
        for(int i=startIndex;i<nums.size();i++){
            if((path.size()!=0&&path.back()>nums[i])||used.find(nums[i])!=used.end()){
                 continue;
            }
            path.push_back(nums[i]);
            used.insert(nums[i]);//不需要erase 本层还需要
            backtracking(nums,i+1);
            path.pop_back();
        }
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        backtracking(nums,0);
        return res;
    }
};

思路：利用unorder_SET对本层元素进行哈希储存

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    void backtracking(vector<int>& nums,vector<bool> &used){
        if(path.size()==nums.size())
        {
            res.push_back(path);
            return;
        }
        for(int i=0;i<nums.size();i++){
             if(used[i])
               continue;
            path.push_back(nums[i]);
            used[i]=true;//递归的时候不在要本元素
            backtracking(nums,used);
            used[i]=false;
            path.pop_back();
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
         vector<bool> used(nums.size(),false);
         backtracking(nums,used);
         return res;
    }
};

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    
    void backtracking(vector<int>& nums, vector<bool>& used) {
        if (path.size() == nums.size()) {
            res.push_back(path);
            return;
        }
        
        for (int i = 0; i < nums.size(); i++) {
            // 如果当前元素被使用过，跳过
            if (used[i]) continue;
            
            // 去重条件：当前元素和前一个元素相同，并且前一个元素还没有被使用过
            if (i > 0 && nums[i] == nums[i-1] && !used[i-1]) continue;
            
            path.push_back(nums[i]);
            used[i] = true;  // 标记当前元素为使用过
            
            backtracking(nums, used);
            
            used[i] = false;  // 回溯，重置状态
            path.pop_back();
        }
    }
    
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        // 为了去重，先对 nums 排序
        sort(nums.begin(), nums.end());
        
        vector<bool> used(nums.size(), false);  // 标记元素是否被使用
        backtracking(nums, used);
        
        return res;
    }
};

思路：used数组是全排列的关键他代表当前元素在递归中有没有被使用同时也有第二个作用在本层循环的时候如果当前元素和前一个元素相同说明之前递归返回了不应该选择重复元素