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

LeetCode 491.递增子序列

链接：491.递增子序列

思路：

看上去和78. 子集很相似，但其实还是有不一样的地方。首先这题并不是每个子节点都需要push进最终结果，而是当path的长度大于等于2才行。然后是判断子序列是否递增，当子序列长度为0时直接把当前值push进path，当长度不为0时判断nums[i]是否大于等于path的最后一位，如果是的话才push进path。到这里为止思路都比较简单，但最麻烦的还是去重的问题。

数组里面还是会出现数字重复的情况，也就是说还会有重复的结果出现，并且这道题目是不能用nums[i-1] == nums[i]这种方式去重的。注意之前为什么能用这种方式去重而这里不行，因为之前每次去重之前都需要对数组进行排序，这样相同的数字会放到一起，就可以用i和i-1的方式对比两数是否相同，但是在这里我们不能对原数组进行排序，因为我们需要保留原数组的排列顺序，在原数组的顺序基础之上寻找递增子序列。

解决的方法是在每一层数层上都用一个hashmap，记录下这一层用了什么数，每次使用这个数后就令hashmap上对应数的值等于1，当在这一层再次遇到这个数的时候直接跳过即可。因为数的大小在-100到100之间，可以使用大小为200的数组来代替unordere_map以节约空间，但是索引的时候要+100不然有可能会取到负数索引而报错。另一点要注意的是，在该层回溯的时候，不要回溯使用过的数，因为我们给每一层一个hashmap，在该层使用过的数不会影响到其他层。

代码：

class Solution {
public:
    vector<int> path;
    vector<vector<int>> ans;
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        backtrackting(nums, 0);
        return ans;
    }
    void backtrackting(vector<int>& nums, int idx)
    {
        int hashmap[201];
        // 不知道为什么必须用这种方法才能把整个数组初始化为0
        for (int i = 0; i < 201; i ++)
            hashmap[i] = 0;
        for (int i = idx; i < nums.size(); i++)
        {
            // 去重，需要记录元素是否用过
            // nums[i] + 100是为了防止索引到负数
            if (hashmap[nums[i] + 100] == 1)
                continue;    
            if (path.size() == 0 || path[path.size()- 1] <= nums[i])
            {
                // 记录用过的数
                hashmap[nums[i] + 100] = 1;
                path.push_back(nums[i]);
                if (path.size() >= 2)
                    ans.push_back(path);
                backtrackting(nums, i + 1);
                path.pop_back();
            }
        }
        
    }
};

LeetCode 46.全排列

链接：46.全排列

思路：

组合和排列最大的区别是，排列可以由相同的组合但不同的顺序组成，换句话说，数组的顺序不影响组合但是影响排列。一组相同的数组，组合是一样的但是顺序换一下就是新的排列。对于这种情况，我们并不需要idx来告诉每一数层开始的位置在哪里，因为实际上每一层的搜索空间大小都是一样的，都是0到nums.size()-1，但是由于每次都从0开始，还是会取到和上一层相同的数字，所以这个时候需要一个used数组来表示上一层用过的数字，从而在这一层避开它。注意在这里回溯是需要给used数组也进行回溯因为数组贯穿了整颗数。

另一种写法是是每次使用一个数后，交换它和idx的位置，这样到下一层的时候就不用担心会取到被用到的数了，因为它在idx的位置，并且下一层是idx+1开始的。这种写法可以避免用到used数组以节约空间。

代码：

class Solution {
public:
    vector<int> path;
    vector<vector<int>> ans;
    vector<vector<int>> permute(vector<int>& nums) {
        vector<bool> used(nums.size());
        backtracking(nums, used);
        return ans;
    }
    void backtracking(vector<int>& nums, vector<bool>& used)
    {
        if (path.size() == nums.size())
        {
            ans.push_back(path);
            return;
        }
        for (int i = 0; i < nums.size(); i++)
        {
            // 跳过选取了的
            if (used[i] == true)
                continue;
            path.push_back(nums[i]);
            used[i] = true;
            backtracking(nums, used);
            // 回溯
            path.pop_back();
            used[i] = false;
            
        }
    }
};

LeetCode 47.全排列 II 

链接：47. 全排列 II

思路：

在46.全排列的基础上增加了去重，去重的思路可以和40.组合总和 II一样，都是利用nums[i-1]==nums[i]，所以在开始之前要对数组排序，之后再利用used数组跳过使用过的数即可。注意这里不能通过交换nums[i]和nums[idx]的方式省略used，因为这样会破坏已经排好的顺序。

代码：

class Solution {
public:
    vector<int> path;
    vector<vector<int>> ans;
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        vector<bool> used(nums.size());
        backtracking(nums, used);
        return ans;
    }
    void backtracking(vector<int>& nums, vector<bool>& used)
    {
        if (path.size() == nums.size())
        {
            ans.push_back(path);
            return;
        }
        for (int i = 0; i < nums.size(); i++)
        {
            // 去重，和40.组合总和 II的去重逻辑是一样的
            // used[i - 1]为true或者false的时候都可以去重
            // 当为true的时候去重的是树枝，为false的时候去重的是树层
            // 树层去重效率更高
            if ((i > 0 && nums[i - 1] == nums[i]) && used[i - 1] == false)
                continue;
            // 跳过选取了的
            if (used[i] == true)
                continue;
            path.push_back(nums[i]);
            used[i] = true;
            backtracking(nums, used);
            // 回溯
            path.pop_back();
            used[i] = false;
            
        }
    }
};