回溯算法：递增子序列全排列全排列II

最新推荐文章于 2024-05-23 09:17:30 发布

暁_

最新推荐文章于 2024-05-23 09:17:30 发布

阅读量1k

点赞数 15

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

本文链接：https://blog.csdn.net/m0_59425585/article/details/134825657

版权

文章讨论了如何使用递归算法解决递增子序列和全排列问题，包括去重策略、回溯方法、终止条件和优化空间复杂度的方法。作者通过实例详细解释了如何在保持序列顺序不变的情况下寻找子序列，以及在处理重复元素的全排列问题时如何进行去重。

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

491.递增子序列

思路：
- 分析题目：
  - 输入一个序列，输出至少有两个元素的递增子序列。所谓序列，就是按照次序排好的行列，因此本题不可以把输入数组重新排序，否则就会改变序列的顺序。因此，不能使用前面90.子集2中的去重逻辑。
  - 本题要取的递增子序列，也就是取有序的子集，且不能有相同的递增子序列。
- 回溯三部曲：
  - 函数参数：需要startIndex，调整下一层递归的起始位置，防止取到重复的元素。
  - 终止条件：相比组合问题收集叶子节点，子集问题收集所有节点，本题更类似子集问题，只是对子集加了限定条件，也就是递增子序列大小至少为2，因此取的不是所有节点。
  - 单层逻辑：
    - 假设给定一个数组[1,3,3,4,2]，横向遍历到第二个3时，以它开头的递增子序列会和前面遍历的3一样，因此要去重，使用一个set来存储遍历过的元素，如果当前遍历到的元素已经存在set中了，就continue遍历下一个元素。
    - 当遍历到2时，如果此时path中末尾是元素3或4，那么加入2就无法构成递增子序列，这种情况也直接continue遍历下一个元素。
- 时间复杂度: O(n * 2^n)
- 空间复杂度: O(n)
- 优化：用数组来做哈希

class Solution {
private:
    vector<int> path;
    vector<vector<int>> res;
    void backtracking(vector<int>& nums, int startIndex) {
        //当path中至少有两个元素时才收集结果
        if(path.size() > 1) res.push_back(path);

        unordered_set<int> uset;//使用set在横向遍历时去重，由于每次递归都会重新定义一个新的set，因此不需要对set进行回溯
        for(int i = startIndex; i < nums.size(); i++) {
            //如果path中有元素，且当前遍历到的元素小于path中最后一个(最大)的元素
            //或 当前遍历元素，已有相同的元素被用过了
            //直接continue继续遍历下一个元素
            if(!path.empty() && nums[i] < path.back()
                || uset.find(nums[i]) != uset.end()) {
                    continue;
            }
            uset.insert(nums[i]);//记录这个元素在本层用过了，本层后面不能再用了
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
    }

public:
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        res.clear();
        path.clear();
        backtracking(nums, 0);
        return res;
    }
};

46.全排列

思路：排列是有序的，也就是说 [1,2] 和 [2,1] 是两个集合，这是和之前分析的子集以及组合所不同的地方。
- 回溯三部曲：
  - 函数参数：排列问题就不需要使用startIndex来去重了，但是需要标记已经使用过的元素，防止排列中出现重复的元素。使用used数组，标记已经选择的元素。
  - 终止条件：叶子节点就是要收集的结果，当path的大小等于输入数组的大小时，就说明是叶子节点，收集结果。
  - 单层逻辑：排列问题，每次都要从头开始搜索，但是一个排列里一个元素只能使用一次，所以要用used数组标记使用过的元素。
- 时间复杂度: O(n!)
- 空间复杂度: O(n)

class Solution {
private:
    vector<int> path;
    vector<vector<int>> res;
    void backtracking(vector<int>& nums) {
        if(path.size() == nums.size()) {
            res.push_back(path);
            return;
        }

        for(int i = 0; i < nums.size(); i++) {
            //如果path中已经有当前元素，直接continue遍历下一元素，防止元素重复
            if(count(path.begin(), path.end(), nums[i])) {
                continue;
            }
            path.push_back(nums[i]);
            backtracking(nums);
            path.pop_back();
        }
    }

public:
    vector<vector<int>> permute(vector<int>& nums) {
        res.clear();
        path.clear();
        backtracking(nums);
        return res;
    }
};

class Solution {
private:
    vector<int> path;
    vector<vector<int>> res;
    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++) {
            //如果path中已经有当前元素，直接continue遍历下一元素，防止元素重复
            if(used[i]) {
                continue;
            }
            used[i] = true;
            path.push_back(nums[i]);
            backtracking(nums, used);
            path.pop_back();
            used[i] = false;
        }
    }

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

47.全排列II

思路：
- 与上一题的区别在于，输入数组可包含重复数字，要返回所有不重复的全排列。因此需要进行去重。去重一定要对元素进行排序，这样我们才方便通过相邻的节点来判断是否重复使用了。
- 横向遍历时(for循环)，如果前一个元素的值与当前遍历元素的值相同，那么就进行去重。
- 使用used数组进行标记，以[1,1,2]为例：纵向遍历到第二个1时，used数组中第一位应该为1，因为纵向上元素可以重复；横向遍历到第二个1时，used数组中第一位应该为0，这是上一层回溯后的结果，说明横向遍历过程中已经使用过1了，直接跳过。
- 时间复杂度: 最差情况所有元素都是唯一的。复杂度和全排列1都是 O(n! * n) 对于 n 个元素一共有 n! 中排列方案。而对于每一个答案，我们需要 O(n) 去复制最终放到 result 数组。
- 空间复杂度: O(n) 回溯树的深度取决于我们有多少个元素

class Solution {
private:
    vector<int> path;
    vector<vector<int>> res;
    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++) {
            // used[i - 1] == true，说明同一树枝nums[i - 1]使用过
            // used[i - 1] == false，说明同一树层nums[i - 1]使用过
            // 如果同一树层nums[i - 1]使用过则直接跳过
            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;
            }
        }
    }

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