代码随想录算法训练营第二十九天|● 491.递增子序列● 46.全排列 ● 47.全排列 II（JS写法）

491 递增子序列

https://programmercarl.com/0491.%E9%80%92%E5%A2%9E%E5%AD%90%E5%BA%8F%E5%88%97.html
视频讲解：https://www.bilibili.com/video/BV1EG4y1h78v

在90.子集II (opens new window)中我们是通过排序，再加一个标记数组来达到去重的目的。

而本题求自增子序列，是不能对原数组进行排序的，排完序的数组都是自增子序列了。

所以不能使用之前的去重逻辑！

本题给出的示例，还是一个有序数组 [4, 6, 7, 7]，这更容易误导大家按照排序的思路去做了。

为了有鲜明的对比，我用[4, 7, 6, 7]这个数组来举例，抽象为树形结构如图：

方法一：用set来处理重复问题，用prev和cur来处理递增问题

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var findSubsequences = function(nums) {
    let res = [];
    let path = [];
    let set = new Set();
    // nums.sort((a,b) => a-b);
    const backTracking = (start) => {
        if(path.length >= 2){
            //转成字符串，方便用set进行去重
            const str = path.toString();
            if(!set.has(str)){
                //向res里推入path的拷贝
                res.push(path.slice());
                //在set里也记录一下，用于判重
                set.add(str);
            }
        }
        for(let i = start;i<nums.length;i++){
            //判断两个元素是否按增序不能用nums[i+1]>nums[i]这种写法
            const prev = path[path.length-1];
            const cur = nums[i];
            //如果path为空或者满足递增关系，则可选择
            if(path.length === 0 || prev <= cur){
                path.push(cur);
                backTracking(i+1);
                path.pop();
            }
        }

    }
    backTracking(0);
    return res;
};

46 全排列

https://programmercarl.com/0046.%E5%85%A8%E6%8E%92%E5%88%97.html
视频讲解：https://www.bilibili.com/video/BV19v4y1S79W

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var permute = function(nums) {
    const res = [];
    const used = {};
    function backTracking(path){
        //终止条件：个数足够
        if(path.length === nums.length){
            res.push(path.slice());
            return;
        }
        //单层循环逻辑
        for(const num of nums){
            //使用过的，跳过
            if(used[num]) continue;
            path.push(num);
            //记录一下使用过
            used[num] = true;
            backTracking(path);
            path.pop();
            //used数组也要进行回溯
            used[num] = false;
        }
    }
    backTracking([]);
    return res;
};

47 全排列Ⅱ

https://programmercarl.com/0047.%E5%85%A8%E6%8E%92%E5%88%97II.html
视频讲解：https://www.bilibili.com/video/BV1R84y1i7Tm

真难，看不下去了，放个题解，排列、组合、子集的去重需要一起看一下，找个时间再看吧。

const permuteUnique = (nums) => {
    const res = [];
    const used = new Array(nums.length);
    nums.sort((a, b) => a - b); // 升序排序

    const helper = (path) => {
        if (path.length == nums.length) { // 个数选够了
            res.push(path.slice());       // path的拷贝 加入解集
            return;                       // 结束当前递归分支
        }

        for (let i = 0; i < nums.length; i++) { // 枚举出所有的选择
            if (used[i]) {                      // 这个数使用过了，跳过。
                continue;
            }
            if (i - 1 >= 0 && nums[i - 1] == nums[i] && !used[i - 1]) { // 避免产生重复的排列
                continue;
            }
            path.push(nums[i]); // make a choice
            used[i] = true;     // 记录路径上做过的选择
            helper(path);       // explore，基于它继续选，递归
            path.pop();         // undo the choice
            used[i] = false;    // 也要撤销一下对它的记录
        }
    };

    helper([]);
    return res;
};