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

491.递增子序列

https://leetcode.cn/problems/non-decreasing-subsequences/

和前面的子集问题比较像，但是因为相同元素不是紧挨着的也不能排序，所以只能使用set容器来进行去重

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backTracking(vector<int> nums, int cur) {
        if (path.size() >= 2) result.push_back(path);
        if (cur >= nums.size()) return;
        unordered_set<int> set;
        for (int i = cur; i < nums.size(); i++) {
            if (!path.empty() && nums[i] < path.back()) continue;
            if (set.find(nums[i]) != set.end()) continue;
            set.insert(nums[i]);
            path.push_back(nums[i]);
            backTracking(nums, i + 1);
            path.pop_back();
        }
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        backTracking(nums, 0);
        return result;
    }
};

46.全排列

https://leetcode.cn/problems/permutations/

本题重要的是遍历的起始位置，每一次遍历都是从头开始

利用一个used来记录元素是否使用过

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    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]) continue;
            path.push_back(nums[i]);
            used[i] = true;
            backTracking(nums, used);
            path.pop_back();
            used[i] = false;
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        vector<bool> used(nums.size(), false);
        backTracking(nums, used);
        return result;
    }
};

直接操作数组：

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backTracking(vector<int> nums) {
        if (nums.empty()) {
            result.push_back(path);
            return;
        }
        for (int i = 0; i < nums.size(); i++) {
            path.push_back(nums[i]);
            nums.erase(nums.begin() + i);
            backTracking(nums);
            nums.insert(nums.begin() + i, path.back());
            path.pop_back();
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        backTracking(nums);
        return result;
    }
};

利用list容器来操作数组：

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backTracking(list<int> nums) {
        if (nums.empty()) {
            result.push_back(path);
            return;
        }
        for (int i = 0; i < nums.size(); i++) {
            auto iter = nums.begin();
            int n = i;
            while(n--) iter++;
            auto next = iter;
            next++;
            path.push_back(*iter);
            nums.erase(iter);
            backTracking(nums);
            nums.insert(next, path.back());
            path.pop_back();
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        list<int> tmpNums(nums.begin(), nums.end());
        backTracking(tmpNums);
        return result;
    }
};

47.全排列 II

https://leetcode.cn/problems/permutations-ii/

和上一题很像，只是多了个排序和去重的逻辑

一个used两用，既用来确认数组中的元素是否使用过，又用来去重： 

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

也可以使用set容器来去重：

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backTracking(vector<int> nums, vector<bool> & used) {
        if(nums.size() == path.size()) {
            result.push_back(path);
            return;
        }
        unordered_set<int> set;
        for (int i = 0; i < nums.size(); i++) {
            if (used[i]) continue;
            if (set.find(nums[i]) != set.end()) continue;
            set.insert(nums[i]);
            path.push_back(nums[i]);
            used[i] = true;
            backTracking(nums, used);
            path.pop_back();
            used[i] = false;
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<bool> used(nums.size(), false);
        sort(nums.begin(), nums.end());
        backTracking(nums, used);
        return result;
    }
};

 也可以直接操作数组

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backTracking(vector<int> nums) {
        if(nums.empty()) {
            result.push_back(path);
            return;
        }
        for (int i = 0; i < nums.size(); i++) {
            if (i > 0 && nums[i] == nums[i-1]) continue;
            path.push_back(nums[i]);
            nums.erase(nums.begin() + i);
            backTracking(nums);
            nums.insert(nums.begin() + i, path.back());
            path.pop_back();
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        backTracking(nums);
        return result;
    }
};

也可以复制一个list来直接操作list

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backTracking(list<int> nums) {
        if(nums.empty()) {
            result.push_back(path);
            return;
        }
        for (int i = 0; i < nums.size(); i++) {
            int n = i;
            auto iter = nums.begin();
            while(n--) iter++;
            auto last = iter;
            auto next = iter;
            next++;
            if (iter != nums.begin() && *iter == *(--last)) continue;
            path.push_back(*iter);
            nums.erase(iter);
            backTracking(nums);
            nums.insert(next, path.back());
            path.pop_back();
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        list<int> lnums(nums.begin(), nums.end());
        backTracking(lnums);
        return result;
    }
};