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

491.递增子序列

题目链接/文章讲解/视频讲解：代码随想录

 1.代码展示

  //491.递增子序列
    vector<int> path;
    vector<vector<int>> result;
    void findSubsequencesBackTracking(vector<int>& nums, int startIndex) {
        //插入路径
        if (path.size() > 1) {
            result.push_back(path);
        }
        //step1 确定参数
        //step2 确定终止条件
        if (startIndex >= nums.size()) {
            return;
        }
        //step3 确定单层递归逻辑
        unordered_set<int> uset;
        for (int i = startIndex; i < nums.size(); i++) {
            //step3.1去重
            //树枝中右数小于左或者树层中有重复元素
            if (path.size() != 0 && nums[i] < path.back() ||
                uset.find(nums[i]) != uset.end()) {
                continue;
            }
            //step3.2记录
            uset.insert(nums[i]);
            path.push_back(nums[i]);
            findSubsequencesBackTracking(nums, i + 1);
            //step3.3回溯
            path.pop_back();
        }
        return;
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        findSubsequencesBackTracking(nums, 0);
        return result;
    }

2.本题小节

        思考：此题也是求子序列，但是与直接求子序列不同，要求递增，集合个数不能超过2，并且要求去重，但是又不能对数组重新进行排序，因此出现了一种新的去重方法，使用uordered_set，由于递增，因此每次插入path之前，要对nums[i]与path.back()作比较。明确了这些，思路就清晰了。

        基本思路：终止条件是startIndex >= nums.size()，这个有没有都可以，毕竟当startIndex = nums.size()时，无法进入for循环，也会直接return掉。单层递归逻辑中，注意unordered_set的位置，它在树层中，所以在for循环中，可以直接用它来寻找一个元素是否出现过，出现过的话直接就跳过，同时注意递增条件，如果不满足，也直接跳过本次循环，注意记录set，并且set不需要回溯，因为它只对本层有效。最后插入路径放在函数的最上层，注意条件，nums.size()>1时才插入。 

46.全排列

题目链接/文章讲解/视频讲解：代码随想录

 1.代码展示

  //46.全排列
    vector<int> path;
    vector<vector<int>> result;
    void permuteBackTracking(vector<int>& nums, vector<bool>& used) {
        //step1 确定参数
        //step2 确定终止条件
        if (path.size() == nums.size()) {
            result.push_back(path);
            return;
        }
        //step3 确定单层逻辑
        for (int i = 0; i < nums.size(); i++) {
            //跳过已经使用的元素
            if (used[i] == true) {
                continue;
            }
            path.push_back(nums[i]);
            used[i] = true;
            permuteBackTracking(nums, used);
            used[i] = false;
            path.pop_back();

        }
        return;
    }
    vector<vector<int>> permute(vector<int>& nums) {
        vector<bool> used(nums.size(), false);
        permuteBackTracking(nums, used);
        return result;
    }

2.本题小节

        思考：本题是全排序中最基本的题目，没有重复元素，并且要对所有的元素进行排序，收获的结果在子节点，这里没有使用到startIndex，每次遍历都是从0开始，用used来标记元素是否被使用过，最后在叶子节点处收获结果。

        基本思路：终止条件是path.size() == nums.size()，此时达到叶子节点，可以收获结果；单层递归逻辑中，从0开始遍历，碰到使用过的元素不再使用，并对used和path进行回溯，需要画图理解，非常朴素的逻辑。 

47.全排列 II

 题目链接/文章讲解/视频讲解：代码随想录

1.代码展示

   //47.全排列Ⅱ
    vector<int> path;
    vector<vector<int>> result;
    void permuteUniqueBackTracking(vector<int>& nums, vector<bool>& used) {
        //step1 确定参数
        //step2 确定终止条件
        if (nums.size() == path.size()) {
            result.push_back(path);
            return;
        }
        //step3 确定单层递归逻辑
        for (int i = 0; i < nums.size(); i++) {
            //step3.1 树层去重
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            //step3.2 如果该元素被使用，那么就跳过
            if (used[i] == true) {
                continue;
            }
            path.push_back(nums[i]);
            used[i] = true;
            permuteUniqueBackTracking(nums, used);
            path.pop_back();
            used[i] = false;
        }
        return;
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        vector<bool> used(nums.size(), false);
        permuteUniqueBackTracking(nums, used);
        return result;
    }

2.本题小节

        思考：本题相对于上题的不同在于，本题有重复的元素，因此需要去重， 去重的时候需要先对数组进行排序，再通过used对树层进行去重即可，这个前面已经讲了很多次了。本题相对于上题仅多了一个去重的步骤，就不再赘述