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 = 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();
            }
        }
    }
};

你可能感兴趣的:(算法,数据结构,javascript,前端)