代码随想录算法训练营第二十三天 |491.递增子序列 46.全排列 47.全排列 II 332.重新安排行程 51.N皇后 37.解数独

491. 非递减子序列

在老问题上又一次出错了

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;

    void backtracking(vector<int>& nums,int index)
    {
        if(path.size() > 1)//注意这里可以不用写终止条件，因为不清楚递归终点
        {
            res.push_back(path);
        }

        unordered_set<int> used;
//因为不能改变数组的顺序，所以只能使用used数组来进行去重操作
//unordered_set<int> uset; 是记录本层元素是否重复使用，
//新的一层uset都会重新定义（清空），所以要知道uset只负责本层！
        for(int i = index;i < nums.size();i++)
        {
//            if((path.back() > nums[i] && (!path.empty() ))|| used.find(nums[i]) != used.end())
//我服了，老错误了，先判空再判断，在这出了很多次问题
            if((!path.empty() && path.back() > nums[i] )|| used.find(nums[i]) != used.end())      
            {
                continue;
            }
            used.insert(nums[i]);
            path.push_back(nums[i]);
            backtracking(nums,i+1);
            path.pop_back();
        }
    }

    vector<vector<int>> findSubsequences(vector<int>& nums) 
    {
        res.clear();
        path.clear();
        backtracking(nums,0);
        return res;
    }
};

46. 全排列

需要把used一起传入进去，这个我没理解到位

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    unordered_set<int> used;

    void backtracking(vector<int>& nums,unordered_set<int> used)//想要实现每层都去重，就把used也传入去
    {
        if(path.size() == nums.size())
        {
            res.push_back(path);
            return;
        }
        for(int i = 0 ; i < nums.size() ; i++)
        {
            if(!used.empty() && used.find(nums[i]) != used.end())
            {
                continue;
            }
            used.insert(nums[i]);
            path.push_back(nums[i]);
            backtracking(nums,used);
            path.pop_back();
            used.erase(nums[i]);
        }
    }

    vector<vector<int>> permute(vector<int>& nums) 
    {
        backtracking(nums,used);
        return res;
    }
};

47. 全排列 II

这题好抽象啊，下去多看看

错误代码：

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    unordered_set<int> used;
    void backtracking(vector<int>& nums,unordered_set<int> used,int index)
    {
        if(path.size() == nums.size())
        {
            res.push_back(path);
            return;
        }

        for(int i = index; i < nums.size(); i++)
        {
            if(!used.empty() && used.find(nums[i]) != used.end())
            {
                continue;
            }
            used.insert(nums[i]);
            path.push_back(nums[i]);
            backtracking(nums,used,i+1);
            path.pop_back();
            used.erase(nums[i]);
        }

    }

    vector<vector<int>> permuteUnique(vector<int>& nums) 
    {
        sort(nums.begin(),nums.end());
        backtracking(nums,used,0);
        return res;
    }
};

正确代码：
 

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;

    void backtracking(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(i > 0 && nums[i] ==  nums[i-1] && used[i-1] == false)
            {
                continue;
            }
            if(used[i] == false)
            {
            used[i] = true;
            path.push_back(nums[i]);
            backtracking(nums,used);
            path.pop_back();
            used[i] = false;
            }
        }

    }

    vector<vector<int>> permuteUnique(vector<int>& nums) 
    {
        res.clear();
        path.clear();
        sort(nums.begin(),nums.end());
        vector<bool> used(nums.size(),false);
        backtracking(nums,used);
        return res;
    }
};