算法练习day25

一、非递减子序列

每一层通过一个set去重

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var findSubsequences = function (nums) {
    let result = []
    let path = []
    function backtracking(startIndex) {
        if (path.length >= 2) {
            result.push([...path])
        }
        let set = new Set()
        for (let i = startIndex; i < nums.length; i++) {
            if ((path.length > 0 && nums[i] < path[path.length - 1]) || set.has(nums[i])) {
                continue
            }
            set.add(nums[i])
            path.push(nums[i])
            backtracking(i + 1)
            path.pop()
        }
    }
    backtracking(0)
    return result
};

二、全排列

排列是有序的，所以不用startIndex

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var permute = function(nums) {
    let result = []
    let path = []
    function backtracking() {
        if(path.length === nums.length) {
            result.push([...path])
            return
        }
        for(let i = 0; i < nums.length;i++) {
            if(!path.includes(nums[i])) {
                path.push(nums[i])
                backtracking()
                path.pop()
            }
        }
    }
    backtracking()
    return result
};

三、全排列2

used[i - 1] == true，说明同一树枝nums[i - 1]使用过

used[i - 1] == false，说明同一树层nums[i - 1]使用过

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var permuteUnique = function (nums) {
    let result = []
    let path = []
    function backtracking(used = {}) {
        if (path.length === nums.length) {
            result.push([...path])
            return
        }
        for (let i = 0; i < nums.length; i++) {
            if (i > 0 && nums[i] === nums[i - 1] && !used[i-1]) {
                continue
            }
            if (!used[i]) {
                used[i] = true
                path.push(nums[i])
                backtracking(used)
                path.pop()
                used[i] = false
            }
        }
    }
    nums.sort((x, y) => x - y)
    backtracking()
    return result
};