代码随想录算法训练营day29 | 491.递增子序列、46.全排列、47.全排列 II

递增子序列

链接: 递增子序列

给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

示例 1：

输入：nums = [4,6,7,7]
输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]
示例 2：

输入：nums = [4,4,3,2,1]
输出：[[4,4]]

思路

只不过这里又有一个额外的条件：组合中所有元素都必须是递增顺序。我们只需要添加一个 track.getLast() > nums[i] 条件即可。

另外，一文秒杀所有排列组合子集问题 中是利用排序的方式防止重复使用相同元素的，但这道题不能改变 nums 的原始顺序，所以不能用排序的方式，而是用 used 集合来避免重复使用相同元素。

综上，只要把 40. 组合总和 II 的解法稍改一下即可完成这道题。

解题方法

看代码即可

复杂度

• 时间复杂度：O(n * 2^n)
• 空间复杂度：O(n)

Code

class Solution {
public:
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        if (nums.empty()) {
            return res;
        }
        backtrack(nums, 0);
        return res;
    }
    
private:
    vector<vector<int>> res;
    // 记录回溯的路径
    deque<int> track;  
    
    // 回溯算法主函数
    void backtrack(vector<int>& nums, int start) {
        if (track.size() >= 2) {
            // 找到一个合法答案
            res.push_back(vector<int>(track.begin(), track.end()));
        }
        // 用哈希集合防止重复选择相同元素
        unordered_set<int> used;
        // 回溯算法标准框架
        for (int i = start; i < nums.size(); i++) {
            // 保证集合中元素都是递增顺序
            if (!track.empty() && track.back() > nums[i]) {
                continue;
            }
            // 保证不要重复使用相同的元素
            if (used.count(nums[i])) {
                continue;
            }
            // 选择 nums[i]
            used.insert(nums[i]);
            track.push_back(nums[i]);
            // 递归遍历下一层回溯树
            backtrack(nums, i + 1);
            // 撤销选择 nums[i]
            track.pop_back();
        }
    }
};

全排列

链接: 全排列

思路

还是用回溯暴力

解题方法

看代码即可

复杂度

• 时间复杂度：O(n!)
• 空间复杂度：O(n)

Code

class Solution {
public:
    vector<vector<int>> res;

    /* 主函数，输入一组不重复的数字，返回它们的全排列 */
    vector<vector<int>> permute(vector<int>& nums) {
        // 记录「路径」
        deque<int> track;
        // 「路径」中的元素会被标记为 true，避免重复使用
        vector<bool> used(nums.size(), false);
        
        backtrack(nums, track, used);
        return res;
    }

    // 路径：记录在 track 中
    // 选择列表：nums 中不存在于 track 的那些元素（used[i] 为 false）
    // 结束条件：nums 中的元素全都在 track 中出现
    void backtrack(vector<int>& nums, deque<int>& track, vector<bool>& used) {
        // 触发结束条件
        if (track.size() == nums.size()) {
            res.push_back(vector<int>(track.begin(), track.end()));
            return;
        }

        for (int i = 0; i < nums.size(); i++) {
            // 排除不合法的选择
            if (used[i]) {



                // nums[i] 已经在 track 中，跳过
                continue;
            }
            // 做选择
            track.push_back(nums[i]);
            used[i] = true;
            // 进入下一层决策树
            backtrack(nums, track, used);
            // 取消选择
            track.pop_back();
            used[i] = false;
        }
    }
};

全排列 II

链接: 全排列 II

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例 1：

输入：nums = [1,1,2]
输出：
[[1,1,2],
[1,2,1],
[2,1,1]]
示例 2：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

思路

对比一下之前的标准全排列解法代码，这段解法代码只有两处不同：

1、对 nums 进行了排序。

2、添加了一句额外的剪枝逻辑。

类比输入包含重复元素的子集/组合问题，你大概应该理解这么做是为了防止出现重复结果。

但是注意排列问题的剪枝逻辑，和子集/组合问题的剪枝逻辑略有不同：新增了 !used[i - 1] 的逻辑判断。

显然，这个结果存在重复，比如 [1,2,2’] 和 [1,2’,2] 应该只被算作同一个排列，但被算作了两个不同的排列。

所以现在的关键在于，如何设计剪枝逻辑，把这种重复去除掉？

答案是，保证相同元素在排列中的相对位置保持不变。

比如说 nums = [1,2,2’] 这个例子，我保持排列中 2 一直在 2’ 前面。

这样的话，你从上面 6 个排列中只能挑出 3 个排列符合这个条件

这也就是正确答案。

进一步，如果 nums = [1,2,2’,2’‘]，我只要保证重复元素 2 的相对位置固定，比如说 2 -> 2’ -> 2’'，也可以得到无重复的全排列结果。

仔细思考，应该很容易明白其中的原理：

标准全排列算法之所以出现重复，是因为把相同元素形成的排列序列视为不同的序列，但实际上它们应该是相同的；而如果固定相同元素形成的序列顺序，当然就避免了重复。

当出现重复元素时，比如输入 nums = [1,2,2’,2’‘]，2’ 只有在 2 已经被使用的情况下才会被选择，同理，2’’ 只有在 2’ 已经被使用的情况下才会被选择，这就保证了相同元素在排列中的相对位置保证固定。

这里拓展一下，如果你把上述剪枝逻辑中的 !used[i - 1] 改成 used[i - 1]，其实也可以通过所有测试用例，但效率会有所下降，这是为什么呢？

之所以这样修改不会产生错误，是因为这种写法相当于维护了 2’’ -> 2’ -> 2 的相对顺序，最终也可以实现去重的效果。

但为什么这样写效率会下降呢？因为这个写法剪掉的树枝不够多。

解题方法

看代码

复杂度

• 时间复杂度：O(n! * n)
• 空间复杂度：O(n)

Code

// An highlighted block
var foo = 'bar';