代码随想录算法训练营第二十三天| 491.递增子序列, 46.全排列, 47.全排列 II, 51. N皇后

今天是回溯算法学习的第四天，完成了回溯算法一刷的所有内容。今天的主要学习内容如下所示：对于非有序数列的去重操作，对有序数列进行全排列，对有序数列全排列并树层去重，以及经典的N皇后问题。

491.递增子序列

题目链接：491. 非递减子序列 - 力扣（LeetCode）

这个题目的难点在于，需要对一个非有序的数列进行有效的去重，这就意味着我们不能用之前的判断相邻元素是否被使用过的方法进行去重。这里使用的是unordered_map进行去重操作，也是非常有效的，也提醒到我容器这一块目前还掌握的比较差。具体代码实现如下所示：

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

由于nums.length是小于15的，我们也可以手动构建一个哈希表，可以大大降低算法时间。具体代码实现如下：
 

class Solution {
public:
vector<int> vec;
vector<vector<int>> result;
void backtracking(vector<int>& nums,int startindex)
{
    if(vec.size()>=2) result.push_back(vec);
    unordered_set<int> uset;
    bool used[500]={0};
    for(int i=startindex;i<nums.size();i++)
    {
        if((!vec.empty()&&nums[i]<vec.back())||used[nums[i]+100]!=0) continue;
            used[nums[i]+100]=1;
            vec.push_back(nums[i]);
            backtracking(nums,i+1);
            vec.pop_back();
        
    } 
}
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        backtracking(nums,0);
        return result;
    }
};

 46.全排列

题目链接：46. 全排列 - 力扣（LeetCode）

对于全排列问题，每一次递归的取值都是在剩下的所有元素中进行选取，所以就需要判断某个数是否被使用过。这里可以使用used数组完成这个事情。具体代码实现如下所示：
 

class Solution {
public:
    vector<int> vec;
    vector<vector<int>> result;
    void backtacking(vector<int> &nums,int num,vector<bool> &used)
    {
        if(num==nums.size()) 
        {
           result.push_back(vec);
            return;
        } 
        for(int i=0;i<nums.size();i++)
        {
            if(used[i]==0)
            {
                 used[i]=1;
                 vec.push_back(nums[i]);
                 backtacking(nums,num+1,used);
                 vec.pop_back();
                 used[i]=0;
            }
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        if(nums.size()==0) return result;
        vector<bool> used(nums.size(),false);
        backtacking(nums,0,used);
        return result;
    }
};

47.全排列 II

题目链接：47. 全排列 II - 力扣（LeetCode）

这个题目的不同在于在全排列的基础上加入了重复元素，需要进行树层去重。那么这就来到了我们最熟悉的领域。具体代码实现如下所示：
 

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

51. N皇后

题目链接：51. N 皇后 - 力扣（LeetCode）

本来N皇后是二刷题的，但是作为一道很经典的回溯问题的例题，还是把这道题做出来了。首先我们先明确一下题目的要求，在一个NxN的棋盘上放置皇后，要求每一行，每一列，每一对角线和反对角线都不会出现重复。所以我们的递归深度是行数，单层递归遍历每一列的元素，如果该位置是一个可行的位置，就放入元素。对于某元素是否能够放入皇后，由于我们的单层递归逻辑是遍历列，所以只需要判断行是否存在重复，对角线是否存在重复和反对角线是否存在重复。具体代码的实现过程如下所示：

class Solution {
public:
vector<vector<string>> result;
void backtracking(int n,int raw,vector<string> &vec)
{
    if(raw==n) 
    {
        result.push_back(vec);
        return;
    }
    for(int col=0;col<n;col++)
    {
        if(isvaild(raw,col,n,vec)==1)
        {
            vec[raw][col]='Q';
            backtracking(n,raw+1,vec);
            vec[raw][col]='.';
        }
    }
}
bool isvaild(int raw,int col,int n,vector<string> &vec)
{
    for(int i=0;i<raw;i++)
    {
        if(vec[i][col]=='Q') return false; 
    }
    for(int i=raw,j=col;i>=0&&j>=0;i--,j--)
    {
        if(vec[i][j]=='Q') return false;
    }
    for(int i=raw,j=col;i>=0&&j<n;i--,j++)
    {
        if(vec[i][j]=='Q') return false;
    }
    return true;
}

    vector<vector<string>> solveNQueens(int n) {
        std::vector<std::string> vec(n, std::string(n, '.'));
        backtracking(n,0,vec);
        return result;
    }
};