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

回溯算法解决递增子序列与全排列问题

最新推荐文章于 2025-12-04 22:20:49 发布

原创最新推荐文章于 2025-12-04 22:20:49 发布 · 128 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #算法 #leetcode

文章介绍了使用回溯算法解决递增子序列和全排列问题的C++实现。在递增子序列问题中，通过维护一个vec和一个uset，避免重复和无效的搜索。全排列问题中，利用backtracking函数和used数组记录元素使用状态，生成所有可能的排列。全排列II中，增加了去重和剪枝操作，通过排序和哈希表优化了算法效率。

491.递增子序列

具体来说，backtracking函数接受两个参数，一个是数组nums，一个是startIndex表示从哪个位置开始寻找递增子序列。该函数内部使用了一个vector<int> vec来存储当前找到的递增子序列，使用了一个unordered_set<int> uset来判断当前数是否已经使用过。如果vec中已经有元素且当前元素小于vec中的最后一个元素，或者当前元素已经被使用过，则直接跳过这个元素，否则将当前元素加入vec中，继续向后搜索，直到达到数组末尾或者vec中的元素个数达到2为止。如果vec的长度大于等于2，则将其加入到result中保存。最后，backtracking函数返回时，需要将vec的最后一个元素弹出，以便继续搜索下一个可能的递增子序列。

class Solution {
private:
    vector<int> vec;
    vector<vector<int>> result;
    void backtracking(vector<int>& nums, int startIndex){
        if (vec.size() > 1){
             result.push_back(vec);
        }
        unordered_set<int> uset;//判断当前数是否已经用过
        for(int i = startIndex;i < nums.size();i++){
            if ((!vec.empty() && nums[i] < vec.back())
            || uset.find(nums[i]) != uset.end()) {
            continue;
         }
         uset.insert(nums[i]);
         vec.push_back(nums[i]);
         backtracking(nums, i+1);
         vec.pop_back();
        }
    }
public:
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        backtracking(nums, 0);
        return result;
    }
};

46.全排列

具体来说，它从nums数组中选择未被使用过的元素，并将其加入到vec数组中，标记其已被使用，然后递归调用backtracking函数，接着回溯，将vec数组中的最后一个元素弹出，同时将对应的标记设为未被使用，最终得到所有的全排列。

这段代码中使用了一个辅助数组used，用于记录nums数组中的元素是否被使用过。backtracking函数中，我们首先检查当前的nums[i]元素是否被标记为已使用，如果已使用，则直接跳过，否则将其加入vec数组中，并将对应的used[i]标记设为true，然后递归调用backtracking函数，接着回溯，将vec数组中的最后一个元素弹出，同时将对应的used[i]标记设为false，最终得到所有的全排列。

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

        }
    }
public:
    vector<vector<int>> permute(vector<int>& nums) {
        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return result;

    }
};

47.全排列 II

算法的主要思想是：对于每个位置，依次枚举数组中没有被使用过的元素，并加入到当前排列中，然后继续往下递归。当排列长度达到数组的长度时，将当前排列加入到结果集中。在枚举过程中，需要进行一些剪枝操作，例如去重和剪枝。

具体来说，去重操作是通过使用一个哈希表uset来实现的，每次枚举时，先判断当前元素是否已经在当前排列中或已经被使用过，如果是，就跳过当前元素。剪枝操作是通过对数组进行排序来实现的，如果当前元素和前一个元素相同，并且前一个元素没有被使用过，就跳过当前元素，因为它和前一个元素的排列是重复的。

class Solution {
private:
    vector<int> vec;
    vector<vector<int>> result;
    void backtracking(vector<int>& nums, vector<bool>& used){
        if(vec.size() == nums.size()){
            result.push_back(vec);
            return;
        }
        unordered_set<int> uset;
        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;
                vec.push_back(nums[i]);
                backtracking(nums, used);
                vec.pop_back();
                used[i] = false;
            }
        }

    }
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vec.clear();
        result.clear();
        sort(nums.begin(), nums.end());
        vector<bool> used(nums.size(),false);
        backtracking(nums, used);
        return result;

    }
};