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

491.递增子序列

本题思路：

（1）去重：利用unordered_set进行去重，记录本层的元素，如果没有重复,返回容器的end()迭代器。
unordered_set uset; 是记录本层元素是否重复使用，新的一层uset都会重新定义（清空），所以uset只负责本层！
（2）保证子序列中递增

因此不满足要求的条件为：

 if((!path.empty() && nums[i] < path.back()) || uset.find(nums[i]) != uset.end()){
                continue;
 }

---

class Solution {
private:
    vector<int> path;
    vector<vector<int>>result;
    void backtracking(vector<int>& nums, int startIndex){
        //保证递增子序列中至少有两个元素
        if(path.size() > 1){
             result.push_back(path);
             //不能加return，因为要取树上符合条件的节点，而不是仅仅取叶子节点
        }
        unordered_set<int>uset;//用于在树层中去重
        for(int i = startIndex; i < nums.size(); i++){
            //对不满要求的树枝需要砍掉（不满足递增子序列，或者在本层中出现重复的数）
            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) {
        result.clear();
        path.clear();
        backtracking(nums, 0);
        return result;

    }
};

46.全排列

思路：本题中，在上一层使用的值在递归到下一层后就不能使用了，因此需要一个数组记录当前值的状态。
采用vector<bool> used，当使用当前值时，used[i] = true，当回溯时，used[i] = false。

---

class Solution {
private:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(vector<int>& nums, vector<bool>& used){
        if(path.size() == nums.size()){
            result.push_back(path);
            return;
        }
        for(int i = 0; i < nums.size(); i++){
            //用于判断当前值是否在上一层使用
            if(used[i] == true)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) {
        result.clear();
        path.clear();
        vector<bool>used(nums.size(), false);
        backtracking(nums, used);
        return result;
    }
};

全排列 II

思路：本题有两部分去重
（1）使用unordered_set<int>对同一层中的重复元素去重:

if(uset.find(nums[i]) != uset.end()) continue;

(2)使用下标状态数组used[i]去掉上一层使用过的元素:

if(used[i] == true) continue;

其中，将used[i]的初始值设为false:

vector<bool>used(nums.size(), false);

同时在本层遍历结束后要及时进行回溯：

used[i] = false;

---

class Solution {
private:
    vector<int>path;
    vector<vector<int>> result;
    void backtracking(vector<int>& nums, vector<bool>& used){
        if(path.size() == nums.size()){
            result.push_back(path);
            return;
        }
        unordered_set<int>uset;
        for(int i = 0; i < nums.size(); i++){  
            //找到同一层的重复元素
            if(uset.find(nums[i]) != uset.end()) continue;
            //找到上一层已经使用过的元素
            if(used[i] == true) continue;
            used[i] = true;
            //将当前元素放入uset
            uset.insert(nums[i]);
            path.push_back(nums[i]);
            backtracking(nums, used);
            path.pop_back();
            used[i] = false;
        }
    }
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        result.clear();
        path.clear();
        vector<bool>used(nums.size(), false);
        backtracking(nums, used);
        return result;
    }
};

此外，对本题进行排序，重复的元素相邻， 因此也可以用另一种去重方式：

//在树层上去重，其中used[i-1] == false表明同一树层used[i-1]使用过，那么已经产生了与当前nums[i]有相同效果的结果
if(i > 0 && nums[i] == nums[i-1] && used[i-1] == false) continue;