排列问题12，组合 dfs，回溯

1 回溯法

回溯法，主要应用在dfs中，主要思想是当你push一个元素后，记住要pop回去，大致的模板是

path.push_back(nums[i]);
dfs(pos+1);
path.pop();

还需要注意到一点是，有时候我们需要一个vis数组记录之前的元素有没有被使用过，常常和回溯一起使用，主要应用的场景是，当我们这次没有成功时，下一次需要从头开始寻找。在我们之前讲到的N皇后问题中，在每一行从的0-j列开始找，如果在这一列没有找到，则直接从下一行找，所以不需要vis数组记录。

if(vis[i]==1) continue; 
vis[i]==1;
path.push_back(nums[i]);
dfs(pos+1);
path.pop();
vis[i]==0;

详细的模板在我们之前用回溯法解决全排列问题有提到。

2 排列问题1

给定一个 没有重复 数字的序列，返回其所有可能的全排列。

2.1 常规dfs

两种写法

vector<vector<int>> ans;
vector<int> nans;
vector<int> vis;
void dfs(int pos,vector<int>& nums)
{
    if(nans.size()==nums.size())
    {
        ans.push_back(nans);
        return;
    }
   for(int i=0; i<nums.size(); i++)
        {
           if(vis[i]==0)
           {
               vis[i]=1;
               nans.push_back(nums[i]);
               dfs(pos+1,nums);
               nans.pop_back();
               vis[i]=0;
           }
        }
}
    vector<vector<int>> permute(vector<int>& nums) {
        vis.assign(nums.size(),0);
        dfs(0,nums);
        return ans;
    }

vector<vector<int>> ans;
vector<int> nans;
vector<int> vis;
void dfs(int pos,vector<int>& nums)
{
    if(pos==nums.size())
    {
        ans.push_back(nans);
        return;
    }
   for(int i=0; i<nums.size(); i++)
        {
           if(vis[i]==0)
           {
               vis[i]=1;
               nans[pos]=nums[i];
               dfs(pos+1,nums);
               vis[i]=0;
           }
        }
}
    vector<vector<int>> permute(vector<int>& nums) {
        vis.assign(nums.size(),0);
        nans.assign(nums.size(),0);
        dfs(0,nums);
        return ans;
    }

2.2 优化dfs

我们也可以通过与排序数组的首元素进行交换来进行优化，这里通过交换，把已经排列的元素交换到前面，随后只关心后面元素的组合，这样就不需要vis数组记录。

vector<vector<int>> ans;
vector<int> nans;
vector<int> nu;
void dfs(int pos)
{
    if(nans.size()==nu.size())
    {
        ans.push_back(nans);
        return;
    }
   for(int i=pos; i<nu.size(); i++)
        {
            nans.push_back(nu[i]);
           std:: swap(nu[i], nu[pos]);
            dfs(pos+1);
             std:: swap(nu[i], nu[pos]);
             nans.pop_back();
           }
       
}
    vector<vector<int>> permute(vector<int>& nums) {
        nu=nums;
        dfs(0);
        return ans;
    }

3 排列问题2

给定一个可包含重复数字的序列，返回所有不重复的全排列。
思路：思路其实适合排列问题1的思路一样，也是可以直接套用模板，分析之后得到只是多了一步剪枝。
如果当前节点和前一节点一样并且前一节点已经被遍历过，则跳过。

class Solution {
public:
vector<int> nu;
vector<int> nans;
vector<vector<int>> ans;
vector<int> vis;
int n;
void dfs(int cur){
    if(cur==n) {
        ans.push_back(nans);
        return;
    }
    else{
        for(int i=0;i<n;i++){
            if(vis[i]==1) continue;
            //如果当前节点和前一节点一样并且前一节点已经被遍历过，则跳过
            iif(i>0&&nu[i-1]==nu[i]&&vis[i-1]==1) continue;
            vis[i]=1;
            nans[cur]=nu[i];
            dfs(cur+1);
            vis[i]=0;
        }
    }
}
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        if(nums.size()==0)
        return ans;
        n=nums.size();
        sort(nums.begin(),nums.end());
        nu=nums;
        nans.assign(n,0);
         vis.assign(n,0);
        dfs(0);
        return ans;
    }
};

3 组合

给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。
思路：
回溯法解决组合问题。和排序问题不同的是，在组合问题中元素的顺序不考虑，只需要从当前位置向后寻找。排序问题每次都需要从头寻找，需要用visited数组记录访问过的元素。
常规bfs模板，第一种方法对于元素只是选和不选的问题 时间复杂度高$O(2^n)$

3.1 常规dfs

class Solution {
public:
  vector<vector<int>>  ans;
    vector<int> nans;
    vector<vector<int>> combine(int n, int k) {
         dfs(1,n,k);
         return ans;
    }
    void dfs(int pos, int n,int k)
    {
        if(nans.size()==k)
         {
             ans.push_back(nans);
             return;
         }
         if(pos>n)
           return;
           nans.push_back(pos);
           dfs(pos+1,n,k);
           nans.pop_back();
             dfs(pos+1,n,k);
    }
};

3.2 优化dfs

第二种方法，利用一个for循环，可以避免重复 （即如果出现1 ，则后面再也不会出现1）

class Solution {
public:
  vector<vector<int>>  ans;
    vector<int> nans;
    vector<vector<int>> combine(int n, int k) {
         dfs(1,n,k);
         return ans;
    }
    void dfs(int pos, int n,int k)
    {
        if(nans.size()==k)
         {
             ans.push_back(nans);
             return;
         }
        for(int i=pos; i<=n; i++)
             {
                 nans.push_back(i);
                 dfs(i+1,n,k);
                  nans.pop_back();
             }
    }
};