回溯 排列问题

leetcode 46

题目描述：

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例 1：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
示例 2：

输入：nums = [0,1]
输出：[[0,1],[1,0]]
示例 3：

输入：nums = [1]
输出：[[1]]

回溯三部曲

因为这题排列是有序的，且是没有重复的序列，所以与之前的组合与分割都不一样的处理方式就是，
不需要startIndex参数来记录初始位置，这里需要从零开始。

参数与返回值

需要一个used数组，标记已经用过的的元素

    vector<vector<int>> result; //记录所有的存储结果
    vector<int> path;
    void backtracking(vector<int>& nums,vector<bool>& used)

终止条件与递归函数

如何判断递归的终止条件呢？就是path的长度和数组nums一样大的时候，说明找到了一个全排列，也表示到达了叶子节点。

//此时说明找到了一组结果
if(path.size() == nums.size())
{
    result.push_back(path);
    return;
}

单层遍历

单层遍历，需要的是从0开始遍历；

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;
      }

整体代码

class Solution {
private:
    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;
          used[i] = true;
          path.push_back(nums[i]);
          backtracking(nums,used);
          path.pop_back();
          used[i] = false;
      }
    }
public:
    vector<vector<int>> permute(vector<int>& nums) {
    result.clear();
    path.clear();
    vector<bool> used(nums.size(),false);
    backtracking(nums,used);
    return result;
    }
};

leetcode 47

题目描述：
给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例 1：

输入：nums = [1,1,2]
输出：
[[1,1,2],
[1,2,1],
[2,1,1]]
示例 2：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

整体代码

class Solution {
private:
   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++)
       {
           //如果used[i-1]==true,则说明同一树枝上使用过nums[i-1]
           //如果used[i-1]==false,则说明同一树层上使用过nums[i-1]
           //如果同一树层上使用过nums[i-1],则直接跳过
           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;
           }
       }
   }
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
     result.clear();
     path.clear();
     sort(nums.begin(),nums.end());
     vector<bool> used(nums.size(),false);
     backtracking(nums,used);
     return result;
    }
};

难点

本题难以理解的就是对于去重的代码逻辑理解

//树层重复
if(i > 0 && nums[i] == nums[i-1] && used[i - 1] == false){
    continue;
}
//树枝重复
if(i > 0 && nums[i] == nums[i-1] && used[i - 1] == true){
    continue;
}