给定一个可包含重复数字的序列 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]]提示：
-
1 <= nums.length <= 8 -
-10 <= nums[i] <= 10c - 参考
- 力扣
/**
* @param {number[]} nums
* @return {number[][]}
*/
var permuteUnique = function(nums) {
let res = [];
let used = {};
let path = [];
nums.sort((a, b) => a - b)
let backTrack = (path, used) => {
if (path.length === nums.length) {
res.push(path);
return;
}
for (let i = 0; i < nums.length; i++) {
if (used[i]) {
continue
}
if (i > 0 && nums[i] === nums[i-1] && !used[i - 1]) {
continue
}
path.push(nums[i])
used[i] = true
backTrack( patah.slice(), used)
path.pop()
used[i] = false
}
}
backTrack( path, used)
return res
};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 中的所有整数 互不相同
/**
* @param {number[]} nums
* @return {number[][]}
*/
var permute = function(nums) {
let res = [];
let path = [];
let used = {};
let backTrack = ( used, path) => {
if (path.length === nums.length) {
res.push(path);
return
}
for (let i = 0; i < nums.length; i++) {
if (used[i]) {
continue
}
path.push(nums[i])
used[i] = true;
backTrack( used, path.slice())
path.pop()
used[i] = false;
}
}
backTrack( used, path)
return res;
};排列问题，讲究顺序（即 [2, 2, 3] 与 [2, 3, 2] 视为不同列表时），需要记录哪些数字已经使用过，此时用 used 数组；
组合问题，不讲究顺序（即 [2, 2, 3] 与 [2, 3, 2] 视为相同列表时），需要按照某种顺序搜索，此时使用 begin 变量。
给定一个无重复元素的正整数数组 candidates 和一个正整数 target ，找出 candidates 中所有可以使数字和为目标数 target 的唯一组合。
candidates 中的数字可以无限制重复被选取。如果至少一个所选数字数量不同，则两种组合是唯一的。
对于给定的输入，保证和为 target 的唯一组合数少于 150 个。
示例 1：
输入: candidates =
[2,3,6,7],
target =
7
输出: [[7],[2,2,3]]
示例 2：
输入: candidates = [2,3,5]
,
target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]
示例 3：
输入: candidates =
[2],
target = 1
输出: []
示例 4：
输入: candidates =
[1],
target =
1
输出: [[1]]
示例 5：
输入: candidates =
[1],
target =
2
输出: [[1,1]]
提示：
1 <= candidates.length <= 30
1 <= candidates[i] <= 200
candidate 中的每个元素都是独一无二的。
1 <= target <= 500
/**
* @param {number[]} candidates
* @param {number} target
* @return {number[][]}
*/
var combinationSum = function(candidates, target) {
// 回溯
let res = [];
// candidates, start 剩余的集合
// sum 终止的条件
// path 当前的栈
let dfs = function(candidates, start, sum, path) {
if (target < sum) {
return;
}
if (sum === target) {
res.push(path);
return
}
for (let i = start; i < candidates.length; i++) {
path.push(candidates[i])
dfs(candidates, i, sum + candidates[i], path.slice())
path.pop();
}
}
return res
}————————————————
