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

491.

> path.back()就可以得到递增

不能排序了这次，这很重要。所以就不能简单地用if i > start来去重，用哈希就行。每层有自己的set，当然这里可以用vector

不需要start ≥ size来当作终止条件。事实上之前的一些题也不需要，因为大于size的start在forloop条件里弄完之后根本就不会进入forloop

这里是记录每一个path。思路和子集一样。

⚠️这里面array的写法是错的！！正确见下题！！⚠️

 46.

排列问题里used变成了需要被回溯的东西（用过的就做一个标记，传入下一个level，下一个level里会挑没用过的）

注意array declare的方法和the fact that

int sum(int array[], int size)与int sum(int * array, int size)没有本质的区别。坍塌现象。

return和continue分开，一个是同层传递，一个是树枝传递。

复制到美国版⬇️

class Solution {
public:
    vector<vector<int>> result;
    void backtracking(vector<int>& nums, vector<int>& path, int used[]){
        if(path.size() == nums.size()){
            result.push_back(path);
            return;
        }
        for(int i = 0; i < nums.size(); i++){
            if(used[nums[i] + 10] == 1){
                continue;
            }
            used[nums[i] + 10] = 1;
            path.push_back(nums[i]);
            backtracking(nums, path, used);
            path.pop_back();
            used[nums[i] + 10] = 0;
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        int used[21] = {0};
        vector<int> path;
        backtracking(nums, path, used);
        return result;

    }
};

47.

去重需要用level used。level used记录已经在本level中用过了的数字的大小，所以里面应该是nums[i]。且因为nums[i] 可能是负数，所以要+10。level used的大小应该是nums里内容的取值范围（-10到10）。

排列需要用arm used。arm used记录第几个nums里的数字已经放到排列里了，所以里面应该是index。arm used的大小应该是nums的size。

复制到美国版⬇️

class Solution {
public:
    vector<vector<int>> result;
    void backtracking(vector<int>& nums, vector<bool>& arm_used, vector<int>& path){
        if(path.size() == nums.size()){
            result.push_back(path);
            return;
        }
        vector<bool> level_used(21, false);
        for(int i = 0; i < nums.size(); i++){
            if(level_used[nums[i] + 10] || arm_used[i] == true){
                continue;
            }
            level_used[nums[i] + 10] = true;
            arm_used[i] = true;
            path.push_back(nums[i]);
            backtracking(nums, arm_used, path);
            path.pop_back();
            arm_used[i] = false;
        }

    } 
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<bool> arm_used(8, false);
        vector<int> path;
        backtracking(nums, arm_used, path);
        return result;
    }
};