代码随想录算法训练营第 25 天 | LeetCode491.递增子序列 LeetCode46.全排列 LeetCode47.全排列ii

代码随想录算法训练营

Day25代码随想录算法训练营第 25 天 | LeetCode491.递增子序列 LeetCode46.全排列 LeetCode47.全排列ii

---

---

前言

LeetCode491.递增子序列

讲解文档

LeetCode46.全排列

讲解文档

LeetCode47.全排列ii

讲解文档

---

一、LeetCode491.递增子序列

1.题目链接

LeetCode491.递增子序列

2.思路

（1）这道题和子集很像，都是保存大部分节点，所以保存答案是单层递归的一部分，每层保存一次答案，保存答案以后不进行返回
（注意，如果要写边界条件返回，要写在保存答案的后面，否则达到边界条件的答案无法保存）
（2）这道题和子集也有不同
1）不能预先排序
2）去重的操作不同：由于不能预先排序，所以不能用子集问题的与前一个元素比较的方法判断重复，只能用哈希表记录是否在同一层用过

• 这道题要求不能有重复的组合，所以同一层不能用同样的数字
• 数字范围[-100,100]，用数组实现哈希表。我们将数字映射成数组下标：nums[i]+100
• used数组在单层递归中定义，每一层都有自己used数组，所以回溯后不要把used数组变成0

3.题解

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    void func(vector<int>& nums, int start) {
        if (path.size() >= 2) {
            res.push_back(path);
        }
        int used[205] = {0};
        for (int i = start; i < nums.size(); i++) {
            if (path.size() && path.back() > nums[i] || used[nums[i] + 100])
                continue;
            path.push_back(nums[i]);
            used[nums[i] + 100] = 1;
            func(nums, i + 1);
            path.pop_back();
        }
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        func(nums, 0);
        return res;
    }
};

二、LeetCode46.全排列

1.题目链接

LeetCode46.全排列

2.思路

（1）参数：
为什么不用start：因为start在组合类问题里控制开始遍历的下标，而排列添加元素的顺序不一定是从前向后
（2）边界条件：
path里面包含所有元素时，存答案并返回
（3）单层递归
从头到尾遍历nums
1）如果元素已经在排列里面，跳过
2）used标记为true，加入排列
3）递归
4）回溯，used标记为false

3.题解

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    vector<bool> used;
    void func(vector<int>& nums) {
        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;
            func(nums);
            used[i] = false;
            path.pop_back();
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        for (int i = 0; i < nums.size(); i++) {
            used.push_back(false);
        }
        func(nums);
        return res;
    }
};

三、LeetCode47.全排列 II

1.题目链接

LeetCode47.全排列 II

2.思路

（1）与前一题区别在nums有重复元素，所以要去重，确保不会有重复的排列（重复的树枝）
（2）去重的两种方法
1）树层去重：避免在同一个树层讨论同一个数字
参考组合ii和子集ii的去重
如果元素和上一个元素相等，并且上一个元素在排列没出现，将在同一层竞争，跳过

if (i > 0 && nums[i] == nums[i - 1] && used[i - 1]==flase)
                continue;

树层去重
2）树枝去重

if (i > 0 && nums[i] == nums[i - 1] && used[i - 1])
                continue;

树枝去重示意图

3.题解

树层去重

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

树枝去重

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    vector<bool> used;
    void func(vector<int>& nums) {
        if (nums.size() == path.size()) {
            res.push_back(path);
            return;
        }
        for (int i = 0; i < nums.size(); i++) {
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1])
                continue;
            if (used[i])
                continue;
            used[i] = true;
            path.push_back(nums[i]);
            func(nums);
            path.pop_back();
            used[i] = false;
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size(); i++) {
            used.push_back(false);
        }
        func(nums);
        return res;
    }
};

---

总结

• 注意数字去重和元素去重：
  元素去重：元素下标=used数组下标
  数字去重：数字映射成used数组下标

• 区分分割/组合和子集问题
  分割组合：保存叶节点，将保存答案看作边界条件处理的一部分，保存后返回
  子集问题：保存所有节点，将保存答案看作单层递归的一部分，保存后不返回
  子集问题注意把保存答案写在返回的前面

• 排列和组合在写法上不同

  • 排列不需要start，因为每次都从头到尾全部遍历nums
  • 排列需要全局定义used数组标记是否在排列里用了

• 去重问题
  子集、组合、全排列和子集ii、组合ii、全排列ii的区别是后者的nums有重复元素，然而我们不希望收集到重复的子集、组合、元素

• 如果能预先排序，则先排序，全局定义used数组，用下面的代码判断是否重复

if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false)
                continue;

• 如果不可以预先排序，则在每次递归定义used数组，如果used 为真，说明本层用过对应的元素了，跳过。回溯的时候不要把used变回false