DFS 回溯 剪枝 合集

最新推荐文章于 2023-06-25 02:33:34 发布
最新推荐文章于 2023-06-25 02:33:34 发布
阅读量474 收藏 5
点赞数 1
分类专栏： LeetCode 文章标签： leetcode dfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42072280/article/details/104580012
版权

46.全排列

在这里插入图片描述

#python
class Solution:
    #def permute(self, nums: List[int]) -> List[List[int]]:
    def permute(self, nums):
        res = []
        def dfs(newNnums, res1):
            if(newNnums == []):
                res.append(res1)              
                return 

            for i in range(len(newNnums)):                                 
                dfs(newNnums[:i]+newNnums[i+1:], res1+[newNnums[i]])
                #此处用res1+[newNnums[i]]，只是在传参的时候传入变化后的列表，但是res1本身并没有发生变化

        dfs(nums, [])
        return res

#python  这个版本不能得到正确答案    
#这是自己本来的思路  先append，再pop，但是这样会改变res1的值，导致res跟着改变

class Solution:
    #def permute(self, nums: List[int]) -> List[List[int]]:
    def permute(self, nums):
        res = []
        def dfs(newNnums, res1):
            if(newNnums == []):
                res.append(res1)              
                return 

            for i in range(len(newNnums)):                                 
                res1.append(newNnums[i])
                dfs(newNnums[:i]+newNnums[i+1:], res1)
                res1.pop()

        dfs(nums, [])
        return res

#这个是上面版本的修正版本  但这个又要append，又要pop，比较耗时
class Solution:
    #def permute(self, nums: List[int]) -> List[List[int]]:
    def permute(self, nums):
        res = []
        def dfs(newNnums, res1):
            if(newNnums == []):
                res.append(res1[:])              
                return 

            for i in range(len(newNnums)):                                 
                res1.append(newNnums[i])
                dfs(newNnums[:i]+newNnums[i+1:], res1)
                res1.pop()

        dfs(nums, [])
        return res

47.全排列 II

在这里插入图片描述

#python   anan写的 顺利通过
class Solution:
    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        res = []
        def dfs(nums, res1):
            if(nums == []):
                res.append(res1[:])              
                return 
            for i in range(len(nums)): 
                print(i, nums[i], nums[0:i], nums)                   
                if(i > 0 and nums[i] in nums[0:i]):  #加了一个判断条件，如果之前判断过，此处就不用再考虑                  
                    continue                   
                res1.append(nums[i])
                dfs(nums[:i]+nums[i+1:], res1)
                res1.pop()

        dfs(nums, [])
        return res

78.子集

在这里插入图片描述

#python  anan写的  ide可以运行出来 但leetcode会超时
class Solution:
    def subsets(self, nums):
        res = []

        def helper(nums):
            if(nums not in res):
                res.append(nums)

            if(nums == []):
                #print(res)
                return 

            for i in range(len(nums)):
                helper(nums[:i] + nums[i+1:])

        helper(nums)
        return res

#[[1, 2, 3], [2, 3], [3], [], [2], [1, 3], [1], [1, 2]]

#python   anan写的  通过了

class Solution:
    def subsets(self, nums):
        res = []

        def helper(nums, tmp):
            if(tmp not in res):
                res.append(tmp[:])

            for i in range(len(nums)):
                tmp.append(nums[i])
                helper(nums[i+1:], tmp)
                tmp.pop()

        helper(nums, [])
        return res
 #[1,2,3]        [[],[1],[1,2],[1,2,3],[1,3],[2],[2,3],[3]]

90.子集 II

在这里插入图片描述

#python
class Solution:
    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
        res = []

        def helper(nums, tmp):
            if(tmp not in res):
                res.append(tmp[:])

            for i in range(len(nums)):
                tmp.append(nums[i])
                helper(nums[i+1:], tmp)
                tmp.pop()

        helper(sorted(nums), [])    对给定数组进行排序
        return res
 #[1,2,2]    [[],[1],[1,2],[1,2,2],[2],[2,2]]
 #[4,4,4,1,4]      [[],[1],[1,4],[1,4,4],[1,4,4,4],[1,4,4,4,4],[4],[4,4],[4,4,4],[4,4,4,4]]

39.组合总和

在这里插入图片描述
在这里插入图片描述

#python   anan写的  通过啦  啦啦啦

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        res = []

        def helper(candidates, target, tmp):
            if(target == 0):
                res.append(tmp[:])

            for i in range(len(candidates)):
                tmp.append(candidates[i])
                if(target-candidates[i] >= 0):
                    helper(candidates[i:], target-candidates[i], tmp)
                tmp.pop()

        helper(candidates, target, [])
        return res

40.组合总和 II

在这里插入图片描述
在这里插入图片描述

#python
class Solution:
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        res = []

        def helper(candidates, target, tmp):
            if(target == 0):
                res.append(tmp[:])

            for i in range(len(candidates)):
                tmp.append(candidates[i])
                if(target-candidates[i] >= 0 and candidates[i] not in candidates[:i]):  #此处加了一个判断条件
                    helper(candidates[i+1:], target-candidates[i], tmp)
                tmp.pop()

        helper(sorted(candidates), target, [])   #此处对输入数组进行了排序
        return res

77.组合

在这里插入图片描述

#python ana写的
class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        res = []

        def helper(nums, tmp):
            if(len(tmp) == k):
                res.append(tmp[:])
                return
            
            i = 0
            while(nums and i < len(nums)):                
                tmp.append(nums[i])
                #print(tmp)
                helper(nums[i+1:],tmp)
                tmp.pop()
                i+=1

        nums = [i+1 for i in range(n)]        
        helper(nums, [])
        return res
# [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]]

#python  anan写的
class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        res = []

        def helper(nums, tmp):
            if(len(tmp) == k):
                res.append(tmp[:])
                return
            
            for i in range(len(nums)):            
                tmp.append(nums[i])
                #print(tmp)
                helper(nums[i+1:],tmp)
                tmp.pop()
                i+=1

        nums = [i+1 for i in range(n)]        
        helper(nums, [])
        return res

543.二叉树的直径

在这里插入图片描述

DFS 全局变量

在这里插入图片描述

//C
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
int result;

int helper(struct TreeNode * root){   //该结点作为根节点的高度
    int leftHeight;
    int rightHeight;

    if(root){
        //处理左子树
        leftHeight = helper(root->left);
        //处理右子树
        rightHeight = helper(root->right);
        //操作本结点
        result = leftHeight+rightHeight > result ? leftHeight+rightHeight : result;
        return leftHeight>rightHeight ? leftHeight+1 : rightHeight+1;
    }else{
        return 0;
    }   
}

int diameterOfBinaryTree(struct TreeNode* root){
    result = 0;   //刚开始直接在定义全局变量时初始化，老是出错，改在这儿初始化就没有问题了
    helper(root);
    return root ? result : 0;
}

//java
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int result = 0;
    public int diameterOfBinaryTree(TreeNode root) {
        helper(root);
        return result;
    }

    public int helper(TreeNode root){
        int leftHeight;
        int rightHeight;

        if(root != null){
            leftHeight = helper(root.left);
            rightHeight = helper(root.right);
            result = Math.max(leftHeight+rightHeight, result); 
            return Math.max(leftHeight, rightHeight)+1;
        }else{
            return 0;
        }   
    }
}

#python
class Solution(object):
    def diameterOfBinaryTree(self, root):
        self.ans = 1
        def depth(node):
            # 访问到空节点了，返回0
            if not node: return 0
            # 左儿子为根的子树的深度
            L = depth(node.left)
            # 右儿子为根的子树的深度
            R = depth(node.right)
            # 计算d_node即L+R+1 并更新ans
            self.ans = max(self.ans, L+R+1)
            # 返回该节点为根的子树的深度
            return max(L, R) + 1

        depth(root)
        return self.ans - 1

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/diameter-of-binary-tree/solution/er-cha-shu-de-zhi-jing-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

DFS python 不用全局变量

#python
# 返回二元 tuple (depth, diameter)
# depth 表示子树的最大深度，diameter 表示子树的最长路径（直径）
def traverse(root):
    if root is None:
        return (0, 0)

    left_depth, left_diam = traverse(root.left)
    right_depth, right_diam = traverse(root.right)
    # 求二叉树深度的常规方法
    depth = 1 + max(left_depth, right_depth)
    # 套用上面推导出的最长路径公式
    diam = max(left_diam, right_diam, left_depth + right_depth)
    return depth, diam

def diameterOfBinaryTree(root):
    depth, diam = traverse(root)
    return diam

作者：nettee
链接：https://leetcode-cn.com/problems/diameter-of-binary-tree/solution/liang-chong-si-lu-shi-yong-quan-ju-bian-liang-yu-b/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

562.二叉树的坡度

在这里插入图片描述

DFS 全局变量

//java  anan 官方的和此类似
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int tilt;

    public int findTilt(TreeNode root) {
        tilt = 0;
        dfs(root);
        return tilt;
    }

    public int dfs(TreeNode root){
        if(root != null){
            int left = dfs(root.left);
            int right = dfs(root.right);
            tilt += Math.abs(left-right);
            return left+right+root.val;
        }else{
            return 0;
        }
    }
}

110.平衡二叉树

在这里插入图片描述
在这里插入图片描述

DFS全局变量

本题与其他题的区别之处：之前的题都是定义一个全局变量，每个递归都会更改这个全局变量的值，最后返回这个值即可；但是本题属于判断题型，如果定义全局变量，只要这个变量为false，就必须返回false,所以只有在满足某些条件下才需要修改这个全局变量的值。见下：

//java   anan
class Solution {
    boolean balance;

    public boolean isBalanced(TreeNode root) {  
        balance = true;     
        height(root);
        return balance;
    }

    public int height(TreeNode root){
        if(root == null)  return 0;
        int leftHeight = height(root.left);
        int rightHeight = height(root.right);

        if( Math.abs(leftHeight-rightHeight) > 1)   balance = false;
        return Math.max(leftHeight, rightHeight) + 1;
    }

}

DFS 不用全局变量

//java  参考别人的
//每次不平衡时返回一个标志，直到最后
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {

    public boolean isBalanced(TreeNode root) {       
        return height(root) != -1;
    }

    public int height(TreeNode root){
        if(root == null)  return 0;
        int leftHeight = height(root.left);
        int rightHeight = height(root.right);
        if(leftHeight >= 0 && rightHeight >= 0 && Math.abs(leftHeight-rightHeight) <= 1){
            return Math.max(leftHeight, rightHeight) + 1;
        }else{
            return -1;   //-1作为不平衡的标志
        }
    }
}

687.最长同值路径

在这里插入图片描述
在这里插入图片描述

//java  anan 2020.3.10
class Solution {
    int res;

    public int dfs(TreeNode root){
        if(root != null){
            int tmp = 0;   //返回的值  左右子树中等值路径的最大数
            int tmp1 = 0;  //比较的数 该节点同值的最长路径
            int l = dfs(root.left);
            int r= dfs(root.right);


            //System.out.print("val=" +  root.val + " " + l + " " + r);

            if(root.left != null && root.right != null){
                if(root.val == root.left.val && root.val == root.right.val){
                    tmp = Math.max(l,r)+1;  tmp1 = l+r+2;
                }else if(root.val == root.left.val){
                    tmp = l+1;     tmp1 = l+1;
                } 
                else if(root.val == root.right.val){
                    tmp = r+1;    tmp1 = r+1;
                } 
            }else if(root.left != null){
                if(root.val == root.left.val){
                    tmp = l+1;     tmp1 = l+1;
                } 
            }else if(root.right != null){
                if(root.val == root.right.val){
                    tmp = r+1;    tmp1 = r+1;
                } 
            }

            //System.out.print("**" + tmp + res + " ");
            res = Math.max(res, tmp1);
            //System.out.println("**final:" + res + " ");

            return tmp;
        }else{
            return 0;
        }
    }

    public int longestUnivaluePath(TreeNode root) {
        res = 0;
        dfs(root);
        return res;
    }
}

//java
//官解和自己的解法相似，只是自己在处理结点时有点过于繁琐，而官解的这个很简洁，值得学习
class Solution {
    int ans;
    public int longestUnivaluePath(TreeNode root) {
        ans = 0;
        arrowLength(root);
        return ans;
    }
    public int arrowLength(TreeNode node) {
        if (node == null) return 0;
        int left = arrowLength(node.left);
        int right = arrowLength(node.right);
        int arrowLeft = 0, arrowRight = 0;
        if (node.left != null && node.left.val == node.val) {
            arrowLeft += left + 1;
        }
        if (node.right != null && node.right.val == node.val) {
            arrowRight += right + 1;
        }
        ans = Math.max(ans, arrowLeft + arrowRight);
        return Math.max(arrowLeft, arrowRight);
    }
}

作者：LeetCode
链接：https://leetcode-cn.com/problems/longest-univalue-path/solution/zui-chang-tong-zhi-lu-jing-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

129.求根到叶子结点数字之和

在这里插入图片描述
在这里插入图片描述

DFS递归 使用全局变量

问题：python全局变量该怎么用？

#python anan 2020.3.10
class Solution:
    def sumNumbers(self, root: TreeNode) -> int:
        if not root:
            return 0

        res = []
        def dfs(root, tmp):  #tmp当一个字符串  
            if(not root.left and  not root.right):  #叶子结点  左右子树都为空
                tmp = tmp+str(root.val)
                res.append(int(tmp))
                return 
            
            if(root.left):
                dfs(root.left, tmp+str(root.val))
            if(root.right):
                dfs(root.right, tmp+str(root.val))  
                                             
        dfs(root, "")
        print(res)
        return sum(res)

//java  anan
//将每个结点处的值作为字符串，每次遍历一个结点，进行字符串的拼接，到叶子结点后，将这个字符串转化为整型，叠加到全局遍历sum中。
class Solution {
    int sum = 0;

    public void dfs(TreeNode root, String tmp){
        if(root.left==null && root.right==null){
            tmp = tmp+Integer.toString(root.val);
            sum += Integer.parseInt(tmp.toString());
            return ;
        }
        if(root.left != null)  dfs(root.left, tmp+Integer.toString(root.val));
        if(root.right !=  null)  dfs(root.right, tmp+Integer.toString(root.val));
    }

    public int sumNumbers(TreeNode root) {
        if(root==null)   return 0;
        dfs(root, new String(""));
        return sum;
    }
}

DFS 不用全局变量，通过变量回传

//java 别人的  这段代码太漂亮了
class Solution {
    public int sumNumbers(TreeNode root) {
        return helper(root, 0);
    }

    public int helper(TreeNode root, int i){
        if(root == null)  return 0;
        int temp = i*10+root.val;
        if(root.left == null && root.right == null)
            return temp;
        return helper(root.left, temp) + helper(root.right, temp);

    }
}
// 作者：liuzhaoce
// 链接：https://leetcode-cn.com/problems/sum-root-to-leaf-numbers/solution/0-ms-jiao-ke-shu-ji-jie-da-by-liuzhaoce/
// 来源：力扣（LeetCode）
// 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
安安csdn
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
DFS中的奇偶剪枝
chyshnu的专栏
02-01 7043
什么是奇偶剪枝？把矩阵看成如下形式： 0 1 0 1 0 1 1 0 1 0 1 0 0 1 0 1 0 1 1 0 1 0 1 0 0 1 0 1 0 1 从为 0 的格子走一步，必然走向为 1 的格子 。 从为 1 的格子走一步，必然走向为 0 的格子 。 即： 从 0 走向 1 必然是奇数步，从 0 走向 0 必然是偶数步。所以当遇到从 0 走向 0 但是要求时间是奇数的或者 从 1 走向 0 但是要求时间是偶数的，都可以直接判断不可
回溯详解以及与 DFS 算法的关联
Herishwater的博客
08-10 5642
概述 回溯法是一种选优搜索法（试探法），被称为通用的解题方法，这种方法适用于解一些组合数相当大的问题。通过剪枝（约束+限界）可以大幅减少解决问题的计算量（搜索量）。 深度优先搜索（Depth-First-Search，DFS）是一种用于遍历或搜索树或图的算法。沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所在边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到...
DFS总结
RUN
11-18 185
n = length m = width def dfs(x, y): if not 0 <= x < n or not 0 <= y < m: # 判断条件 return board[x][y] = "A"###操作 dfs(x + 1, y) dfs(x - 1, y) dfs(x, y + 1) dfs(x, y - 1) 举例： 被围绕的区域 给定一个二维的矩阵，包含 ‘X’ 和 ‘O’（字母 O）
递归、dfs、回溯、剪枝，一针见血的
RGHLY21的博客
02-02 3324
递归、dfs、回溯，一针见血的
回溯法-------0-1背包问题（DFS、剪枝函数）
热门推荐
zr147258369的博客
04-19 2万+
一 回溯法概述 回溯法的思路主要可以概述为以下2点： （1）把问题的解空间转化成了图或者树的结构 （2）使用深度优先搜索策略进行遍历，遍历的过程中记录和寻找所有可行解或者最优解。 二 深度优先搜索策略（DFS） 深度优先遍历一般只在图和树中涉及，当然，树是图的一种特殊结构。DFS简要来说就是对每一个可能的分支路径深入到不能再深入为止，且不能重复遍历，即每个节点只能遍历一次。 下边举两个例子 说明一下DFS，帮助理解。 1 树中的深度优先遍历 如图所示：是一个二叉树，其深度遍历的顺序为：.
回溯算法及剪枝
qq_41897304的博客
02-13 4398
回溯算法及剪枝理论基础模板框架实例思路剪枝 回溯算法的本质是暴力穷举，即使用递归控制for循环嵌套的数量，本身不是一个高效的算法。尽管可以使用剪枝来提高效率，但是还是改不了穷举的本质。回溯法，一般用来解决组合，排列，切割，子集，棋盘等问题。 理论基础 回溯法也就是使用递归函数进行解决问题，精髓是使用递归控制for循环嵌套的数量。 解决问题的过程可以抽象为树形结构，即一颗高度有限的树（N叉树）。从根节点一直走到叶子节点。叶子节点为满足条件的一个解决方案。 因为回溯法解决的都是在集合中递归查找子集，所以集合的大
递归回溯深度优先搜索DFS练习题（含C++源码）
02-10
深度优先搜索（Depth First Search，简称DFS）是一种用于遍历或搜索树或图的算法，它按照“尽可能深”的原则访问节点，直到达到叶节点或回溯到无新节点可访问时为止。在这个过程中，DFS通常与递归和回溯策略结合使用...
POJ3009-Curling 2.0【DFS+Vector+回溯+剪枝】
07-31
北京大学在线编程平台上的POJ3009题目名为"Curling 2.0"，它是一道涉及到算法与数据结构的复杂问题，主要考察了参赛者对深度优先搜索（DFS）、向量（Vector）操作、回溯法以及剪枝策略的掌握程度。本题的解决方案...
POJ3373-Changing Digits【DFS+强剪枝】
08-19
深度优先搜索（DFS）是一种常用的图遍历或树遍历方法，它从根节点开始，沿着树（或图）的某一路径一直探索到叶子节点，然后回溯至最近的未访问节点，再继续探索其他分支。在这个问题中，DFS可能被用来遍历所有可能的...
POJ3733-Changing Digits【DFS+强剪枝】
08-18
深度优先搜索（DFS）的基本思想是从起点开始，一直向下探索，直到达到叶子节点或者回溯到一个未被完全探索的节点。在"Changing Digits"这个问题中，DFS可能被用来遍历所有可能的数字变化组合，以满足题目给出的条件...
C++回溯算法实验报告
12-10
回溯算法是一种在问题的解空间树中，按照深度优先搜索策略，通过剪枝操作避免无效搜索，从而求解问题的算法。在这个C++实验中，我们分别通过两个实例来探讨回溯法的应用。 首先，实验的第一个问题是删数问题。这个...
算法：回溯+剪枝
weixin_42067304的博客
12-09 3761
回溯算法的定义： 在包含问题的所有解的解空间树中，按照深度优先的策略，从根结点出发搜索解空间树。算法搜索至解空间树的任一结点时，总是先判断该结点是否肯定不包含问题的解。如果肯定不包含，则跳过对以该结点为根的子树的系统搜索，逐层向其祖先结点回溯。否则，进入该子树，继续按深度优先的策略进行搜索。回溯法在用来求问题的所有解时，要回溯到根，且根结点的所有子树都已被搜索遍才结束。而回溯法在用来求问题的任一解时，只要搜索到问题的一个解就可以结束。 解空间树：依据待解决问题的特性，用树结构表示问题的解结构、用叶子表
算法学习-回溯问题与剪枝
蒋大钊的博客
02-27 684
记录回溯和剪枝算法的刷题过程
回溯注意点：回溯时间复杂度的计算与剪枝操作
CFY1226的博客
06-25 1692
不剪枝的版本会尝试所有的可能组合，直到得到长度为k的组合。然而，对于一些情况，当我们已经选择了足够多的元素，使得剩余的元素不足以填满长度为k的组合时，我们仍然会继续尝试，这其实是无效的。在这种情况下，我们仍然可以使用公式来大致评估时间复杂度，但需要注意，这只是一个大概的评估，因为在某些路径中，可能由于和超过了目标值或者元素数量已满，提前结束了搜索。在电话号码的字母组合问题中，我们需要为输入的每一个数字选择一个字母，每一个数字都有几个可能的字母，我们需要尝试所有的可能选择，以生成所有可能的组合。
算法学习-剪枝&回溯
m0_46614929的博客
06-06 191
函数，i,j表示网格坐标，k表示word的第k个字符，如果能搜索到第k个字符返回true，否则返回false，check函数的终止条件有2种情况。表示节点已经访问过了，然后顺着当前网格坐标的四个方向继续尝试，如果没找到k开始的子串，则回溯状态。函数的时候，进行4个方向的检查，其余坐标的节点都是3个方向检查，走过来的分支不会反方向回去，所以。，M,N 为网格的长度与宽度，L 为字符串 word 的长度，第一次调用。个坐标，且存在剪枝，所以最坏的情况下时间复杂度是。，剪枝之后会优化，最坏的情况是。
Python:路径之谜（DFS剪枝)
qq_65144447的博客
02-12 1077
有时是可以的，比如上图中的例子。为了方便表示，我们约定每个小格子用一个数字代表，从西北角开始编号: 0,1,2,3 ⋯⋯。本题的要求就是已知箭靶数字，求骑士的行走路径（测试数据保证路径唯一）第一行一个整数 N (0≤N≤20)，表示地面有 N×N 个方格。第二行 N 个整数，空格分开，表示北边的箭靶上的数字（自西向东）第三行 N 个整数，空格分开，表示西边的箭靶上的数字（自北向南）小张冒充 X 星球的骑士，进入了一个奇怪的城堡。城堡里边什么都没有，只有方形石头铺成的地面。输出一行若干个整数，表示骑士路径。
回溯-剪枝
qq_41648804的博客
08-13 482
回溯算法也可以认为是某种程度的暴力穷举，但是在暴力穷举的过程中，可以根据解的相关性质将不满足条件的解及时剪枝 相关例题 括号生成 数字 n代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。 示例 1： 输入：n = 3 输出：["((()))","(()())","(())()","()(())","()()()"] class Solution { public: vector<string> vec; void df...
DP(Dynamic Programming)动态规划
weixin_42072280的博客
03-01 1316
动态规划（英语：Dynamic programming，简称 DP）是一种在数学、管理科学、计算机科学、经济学和生物信息学中使用的，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。 动态规划常常适用于有重叠子问题和最优子结构性质的问题，动态规划方法所耗时间往往远少于朴素解法。 动态规划背后的基本思想非常简单。大致上，若要解一个给定问题，我们需要解其不同部分（即子问题），再根据子问题的解...
pythondfs+回溯+剪枝
最新发布
11-08
根据提供的引用内容，没有直接涉及到"pythondfs+回溯+剪枝"的概念。但是可以看出，引用中提到了回溯法，而引用中的代码实现了回溯算法解决括号生成问题。在回溯算法中，通常会使用深度优先搜索（DFS）来遍历所有可能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

安安csdn

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值