回溯

回溯算法

• 算法设计的一种思想
• 渐进式寻找解决问题的方法
• 从一个可能的动作开始解决问题，如果改动作不行，就回溯到最初的状态，选择另一种动作解决问题

LeetCode

46. 全排列

难度中等2249收藏分享切换为英文接收动态反馈

给定一个不含重复数字的数组 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) {

    // 1，2，3 的排列，如果不考虑重复的元素 总数为3*3*3

    // 因为不能出现重复的元素，所以会出现死路（不符合条件）和生路（符合条）两种

    // 对于这种路很多的情况，一般需要使用递归来解决

    let res=[]

    // 定义一个递归的算法
    // let path=[]
    const backTrack=(path)=>{
        // 判断n是否已经在数组中
        
        
        if(path.length===nums.length){
            // console.log(2)
            res.push(path)
            return 
        }
        
        
        
        nums.forEach((item)=>{
            if(path.includes(item)){
            // console.log(1,n)
                return 
            }
            backTrack(path.concat(item))
        })
    }

    backTrack([])

    

    return res
};

78. 子集

难度中等1817收藏分享切换为英文接收动态反馈

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

示例 2：

输入：nums = [0]
输出：[[],[0]]

提示：

• 1 <= nums.length <= 10
• -10 <= nums[i] <= 10
• nums 中的所有元素 互不相同

解题思路

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var subsets = function(nums) {

    //可以使用深度优先搜索

    // 定义一个访问数组
    let res=[]
    let visited=new Array(nums).fill(false)

    backTrace=(path,visited)=>{
        console.log(path)

        if(path.length){
            res.push(path)
        }

        if(path.length===nums.length){
            return 
        }

        nums.forEach((item,index)=>{
            if(!visited[index]){
                
                // 这里只是为了传递形参
                let newVisited=Array.from(visited)
                newVisited[index]=true
                // 这里只是为了传递形参
                backTrace(path.concat(item),newVisited)
                // visited[index]=false
                // 层级加深，当前节点不能在用
                visited[index]=true
            }
        })
    }

    
    backTrace([],visited)
        
    res.unshift([])

    // console.log(visited)

    return res

};