Day25: 回溯算法 IV

491.递增子序列 (需要回看)

给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。

示例:

• 输入: [4, 6, 7, 7]
• 输出: [[4, 6], [4, 7], [4, 6, 7], [4, 6, 7, 7], [6, 7], [6, 7, 7], [7,7], [4,7,7]]

说明:

• 给定数组的长度不会超过15。
• 数组中的整数范围是 [-100,100]。
• 给定数组中可能包含重复数字，相等的数字应该被视为递增的一种情况。

function findSubsequences(nums: number[]): number[][] {
    let results: number[][] = [];

    function backtracking(startIndex: number, result: number[]){
        if(result.length >= 2){
            results.push([...result]);
        }
        let helperSet = new Set();
        for(let i = startIndex; i < nums.length; i++){
            if(helperSet.has(nums[i])) continue;
            if(result.length > 0 && result[result.length - 1] > nums[i]) continue;
            helperSet.add(nums[i]);
            result.push(nums[i]);
            backtracking(i + 1, result);
            result.pop();
        }
        results.push()
    }
    backtracking(0, []);
    return results;
};

这个递增子序列比较像是取有序的子集。而且本题也要求不能有相同的递增子序列。

这又是子集，又是去重，是不是不由自主的想起了刚刚讲过的90.子集II (opens new window)。

就是因为太像了，更要注意差别所在，要不就掉坑里了！

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

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

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

这里 同一父节点下的同层上使用过的元素就不能再使用了，所以我这里使用 Set 来去重。

46.全排列

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

示例:

• 输入: [1,2,3]
• 输出: [ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ]

function permute(nums: number[]): number[][] {
    let results: number[][] = [];
    function backtracking(result: number[], numsArr: number[]){
        if(result.length === nums.length){
            results.push([...result]);
        }
        for(let i = 0; i < numsArr.length; i++){
            let tmpArr = [...numsArr];
            result.push(tmpArr.splice(i, 1)[0]);
            backtracking(result, tmpArr);
            result.pop();
        }
    }
    backtracking([], nums);
    return results;
};

官方题解：

function permute(nums: number[]): number[][] {
    const resArr: number[][] = [];
    const helperSet: Set<number> = new Set();
    backTracking(nums, []);
    return resArr;
    function backTracking(nums: number[], route: number[]): void {
        if (route.length === nums.length) {
            resArr.push([...route]);
            return;
        }
        let tempVal: number;
        for (let i = 0, length = nums.length; i < length; i++) {
            tempVal = nums[i];
            if (!helperSet.has(tempVal)) {
                route.push(tempVal);
                helperSet.add(tempVal);
                backTracking(nums, route);
                route.pop();
                helperSet.delete(tempVal);
            }
        }
    }
};

可以感受出排列问题的不同：

• 每层都是从0开始搜索而不是startIndex
• 需要used数组记录path里都放了哪些元素了

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]]

提示：

• 1 <= nums.length <= 8
• -10 <= nums[i] <= 10

function permuteUnique(nums: number[]): number[][] {
    let results: number[][] = [];
    nums.sort((a, b) => a - b);
    let helperSet2 = new Set();
    function backtracking(result: number[]){
        if(result.length === nums.length){
            results.push([...result]);
        }
        let helperSet = new Set();
        for(let i = 0; i < nums.length; i++){
            if(helperSet.has(nums[i])) continue;
            if(helperSet2.has(i)) continue;
            helperSet.add(nums[i]);
            helperSet2.add(i);
            result.push(nums[i]);
            backtracking(result);
            result.pop();
            helperSet2.delete(i);
        }
    }
    backtracking([]);
    return results;
};

看完官方题解，我以上的解法其实不需要 helperSet，因为在开始我已经排过序了，所以可以直接判断：if (i > 0 && nums[i] === nums[i - 1]) continue;

这道题目和46.全排列 (opens new window)的区别在与给定一个可包含重复数字的序列，要返回所有不重复的全排列。

这里又涉及到去重了。

在40.组合总和II (opens new window)、90.子集II (opens new window)我们分别详细讲解了组合问题和子集问题如何去重。

那么排列问题其实也是一样的套路。

还要强调的是去重一定要对元素进行排序，这样我们才方便通过相邻的节点来判断是否重复使用了。

一般来说：组合问题和排列问题是在树形结构的叶子节点上收集结果，而子集问题就是取树上所有节点的结果。

官方题解：

function permuteUnique(nums: number[]): number[][] {
    nums.sort((a, b) => a - b);
    const resArr: number[][] = [];
    const usedArr: boolean[] = new Array(nums.length).fill(false);
    backTracking(nums, []);
    return resArr;
    function backTracking(nums: number[], route: number[]): void {
        if (route.length === nums.length) {
            resArr.push([...route]);
            return;
        }
        for (let i = 0, length = nums.length; i < length; i++) {
            if (i > 0 && nums[i] === nums[i - 1] && usedArr[i - 1] === false) continue;
            if (usedArr[i] === false) {
                route.push(nums[i]);
                usedArr[i] = true;
                backTracking(nums, route);
                usedArr[i] = false;
                route.pop();
            }
        }
    }
};