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]]
提示：
-
1 <= nums.length <= 6 -
-10 <= nums[i] <= 10 -
nums 中的所有整数互不相同
解析
/**
* @brief 回溯法解决排列问题
*
* 回溯三部曲：
* 1、确定递归函数的参数与返回值
* - 参数： 数组nums ，数组used(记录每层使用的元素)
* - 全局变量： 二维数组 result 记录结果集。一维数组 path 记录找到的子集
*
* 2、确定递归的终止条件
* 将排列过程抽象成树后，所有的子集都在叶子节点，此时子集的大小等于原数组的大小
* - path数组的大小等于 nums数组的大小时，说明找到了一种排列
* 3、确定单层循环的逻辑
* - 修改 used[i] 记录使用过得元素，一个排列里一个元素只能使用一次
* - 将元素添加到子集中
* - 回溯
* 排列问题与组合问题不同之处
* - 每层都是从0开始搜索而不是startIndex
* - 需要使用used数组记录path里面都放了哪些元素
* 排列问题是回溯算法的解决的经典题目
*/
代码
class Solution
{
public:
vector<vector<int>> permute(vector<int> &nums)
{
// 清空数组
result.clear();
path.clear();
// 定义used数组，记录已经使用过的元素
vector<int> used(nums.size(), false);
backtracking(nums, used);
return result;
}
private:
// 结果集
vector<vector<int>> result;
// 子集
vector<int> path;
void backtracking(vector<int> &nums, vector<int> used)
{
// path的大小等于 nums的大小。说明已经找到了一组
if (path.size() == nums.size())
{
// 将子集添加到结果集中
result.push_back(path);
}
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;
}
}
};
47. 全排列 II
题目描述
给定一个可包含重复数字的序列 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]]
解析
/**
* @brief 有重复数据的全排列
* 元素有重复，所以需要进行去重处理
*
* 回溯三部曲：
* 1、确定递归函数的参数与返回值
* - 参数：数组 nums . 数组 used 用来记录使用过得元素
* - 返回值：无
* 2、确定递归函数的终止条件
* - 子集出现在叶子节点，所以当 path的大小等于 nums的大小时就可以停止循环
*
* 3、确定单层循环的逻辑
* - 题述中nums数组中有重复的元素，这就会导致最后的子集会出现重复的
* - 所以需要进行去重处理。
* - 去重条件与组合中去重的条件相同，判断同一树层中的元素是否使用过，使用过就去重
*/
代码
class Solution
{
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;
}
private:
vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int> &nums, vector<bool> &used)
{
// used[i-1] = true ; 同一树枝上出现相同的元素，不需要去重处理
// used[i-1] = false; 同一树层上出现相同的元素，需要去重处理
if (path.size() == nums.size())
{
result.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] == true)
{
continue;
}
used[i] = true;
path.push_back(nums[i]);
backtracking(nums, used);
path.pop_back();
used[i] = false;
}
}
};
