算法学习 | day25/60 递增子序列/全排列/全排列II

一、题目打卡

        1.1 递增子序列

        题目链接：. - 力扣（LeetCode）        

class Solution {
public:
    vector<int> path;
    vector<vector<int>> res;
    int tmp = INT_MIN;
    void recur(vector<int>& nums, int startInd){
        if(path.size() >= 2){
            res.push_back(path);
        }
        if(startInd == nums.size()) return;
        unordered_set<int> used;
        for(int i = startInd; i < nums.size(); i++){
            // if(i > startInd && nums[i] <= nums[i-1] && (!path.empty() && path.back() > nums[i])) continue;
            // if(path.empty() || path.back() <= nums[i]) path.push_back(nums[i]);

            // if(i > startInd && nums[i] == nums[i-1]) continue;
            // if(i > startInd && nums[i] == tmp) continue;
            // if(path.empty() || path.back() <= nums[i]) path.push_back(nums[i]);
            // else continue;
            if(used.find(nums[i]) != used.end() || 
                (!path.empty() && path.back() > nums[i])) continue;
            used.insert(nums[i]);
            path.push_back(nums[i]);
            recur(nums,i+1);
            tmp = path.back();
            path.pop_back();
        }
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        // sort(nums.begin(),nums.end());
        recur(nums,0);
        return res;
    }
};

        这个题目写的过程中表明的坑我好像都踩了（擦汗.jpg），这个题目类似与子集，但是根据题目的要求，这个题目并不能排序，这个题目的去重过程也和之前的不一样，因为没有办法排序，那么在同一层中，就不能使用之前我写的那个条件进行判断了，然后我看了答案，确实解锁了一种新的思路，通过set来存储在同一层（横向）中重复的元素并进行判断，相当于是用空间换时间的一种方法吧，之前的算法，因为可以排序，所以其实节省了这里的一部分空间。

        1.2 全排列

        题目链接：. - 力扣（LeetCode）

class Solution {
public:
    vector<int> path;
    vector<vector<int>> res;
    unordered_set<int> used;
    // vector<int> used;
    void recur(vector<int> &nums){
        if(path.size() == nums.size()){
            res.push_back(path);
            // used.clear();
            return;
        }
        for(int i = 0;i < nums.size();i++){
            // path.push_back(nums[i]);
            // if(path.empty() || path.back() != nums[i])path.push_back(nums[i]);
            // else continue;

            if(used.find(nums[i]) != used.end()) continue;
            used.insert(nums[i]);
            path.push_back(nums[i]);
            recur(nums);
            used.erase(nums[i]);
            path.pop_back();
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        recur(nums);
        return res;
    }
};

        一上来其实思路挺清晰的，很明确的是，求组合的问题，肯定是不需要传递 startInd 去更新每一层的参数的，只是做的过程里面有一点坎坷，不过做出来还是很有收获的，之前我还一直在思考 carl 的那句话，去重包含两个层面的内容，一个是横向的去重，另一个是纵向的去重，这个题目就是纵向的去重，也就是在某一层选择了的元素，在别的层就不能再选择了，和之前在同一层不能选择同一个元素，是两个不同的思路，我解决的办法是维护了一个全局的 set，这里必须是全局的，按照上个题目的声明方法，其实去重的是横向的一个去重。这种方法是可以解决纵向去重的问题的，不过我认为答案的思路其实是更清晰的，也就是每一层传递一个哈希映射：

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] == true) continue; // path里已经收录的元素，直接跳过
            used[i] = true;
            path.push_back(nums[i]);
            backtracking(nums, used);
            path.pop_back();
            used[i] = false;
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        result.clear();
        path.clear();
        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return result;
    }
};

        这个题在做的过程中，其实也复习了：vector没有find方法；erase 是set 的删除方法。

        1.3 全排列II（借助答案思路，两种去重同时使用的情况）

          leetcode链接：. - 力扣（LeetCode）

// class Solution {
// private:
//     vector<int> path;
//     vector<vector<int>> res;
//     void backtrack(vector<int>& nums, vector<bool>& used, int startInd){
//         if(path.size() == nums.size()){
//             res.push_back(path);
//             return;
//         }
//         for(int i = 0; i < nums.size();i++){
//             // if(used[nums[i]]) continue; // 纵向去重
//             if(used[i]) continue; // 纵向去重
//             if(i > startInd && nums[i - 1] == nums[i]) continue; // 横向去重
//             path.push_back(nums[i]);
//             used[i] = true;
//             backtrack(nums, used, i + 1);
//             used[i] = false;
//             path.pop_back();
//         }
        
//     }
// public:
//     vector<vector<int>> permuteUnique(vector<int>& nums) {
//         vector<bool> used(nums.size(),false);
//         backtrack(nums, used, 0);
//         return res;
//     }
// };


class Solution {
private:
    vector<int> path;
    vector<vector<int>> res;
    void backtrack(vector<int>& nums, vector<bool>& used){
        if(path.size() == nums.size()){
            res.push_back(path);
            return;
        }
        for(int i = 0; i < nums.size();i++){
            // if(used[nums[i]]) continue; // 纵向去重
            // if(used[i]) continue; // 纵向去重
            // if(i > 0 && nums[i - 1] == nums[i] && used[i]) continue; // 横向去重
            if(used[i]) continue; // 纵向去重
            if(i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) continue; // 横向去重
            path.push_back(nums[i]);
            used[i] = true;
            backtrack(nums, used);
            used[i] = false;
            path.pop_back();
        }
        
    }
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<bool> used(nums.size(),false);
        sort(nums.begin(),nums.end());
        backtrack(nums, used);
        return res;
    }
};

        这个题目做的过程有一点波折，做出来以后在理解横向去重和纵向去重有了更深的理解，进行了一个小的总结：

        不过还有一个小的细节，就是这里：

if(used[i]) continue; // 纵向去重
if(i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) continue; // 横向去重

        这里横向的去重，之所以还多了一条检测的条件 used[i - 1]，因为在不同层之间，传递的一个起始的 startInd 都是0，或者说对于排列问题，因为其全部都是从 0 开始的，所以不能和之前的那种一样，只判断 i > 0 && nums[i] == nums[i - 1]，在不同层的相同元素就会取不到，比如说 [1, 1, 2]，第一层取 1 ，第二层取第二个 1 的时候，就会直接跳过，这样就会导致结论不正确，因为 112 也是排列的一种，所以才需要再添加一个条件进行横向的去重，这里比较有趣的是，对于used[ i - 1 ] 这个条件，其实判断其为 true 和 false 都是可以的，而区别我觉得这里代码随想录已经讲的很细致了：

        树层上去重(used[i - 1] == false)，的树形结构如下：

        这里实际上就是只处理了回溯过程结束以后前一位重置和递归过程中前一位未被重置的区别来进行剪枝的。

        树枝上去重（used[i - 1] == true）的树型结构如下：

        这样相对会有个更多无用的搜索，而且我感觉这样更不好理解一点，所以最好直接采用上一个方法比较好。