精华内容
下载资源
问答
  • python深度优先搜索
    千次阅读
    2021-09-28 23:47:35

    图的深度优先搜索

    1.利用栈实现
    2.从源节点开始把节点按照深度放入栈,然后弹出
    3.每弹出一个点,把该节点下一个没有进过栈的邻接点放入栈
    4.直到栈变空

    代码

    # 定义节点
    class Node:
        
        def __init__(self,value=None,connect=[]):
            
            self.value=value
            self.connect=connect   # 节点连接的其他节点集合
            
        def setValue(self,value):
            self.value=value
            
        def getValue(self):
            return self.value
        
        def setConnect(self,connect):
            self.connect=connect
            
        def getConnect(self):
            return self.connect
        
        def addConnect(self,node):
            self.connect.append(node)
    
    # 深度优先
    def dfs(node=None):
        if node is None:
            return
        
        nodeSet=set()  # 定义登记节点集合
        stack=[]   # 用List来表示栈
        
        print(node.getValue())  # 打印节点的值
        nodeSet.add(node)  # 登记遍历过的节点
        stack.append(node) # 将节点压入栈
        
        while len(stack)>0:
            
            cur=stack.pop()  # 将list中最末尾的元素删除,并返回元素值
            
            for next in cur.getConnect():   # 遍历该节点的邻接节点
                
                if next not in nodeSet:     # 如果该节点还没登记
                    print(next.getValue())  # 打印邻接节点的值
                    
                    nodeSet.add(next)       # 登记邻接节点
                    stack.append(cur)      # 将节点再次压入
                    stack.append(next)     # 将邻接节点压入  
                    break  # 退出,保持深度优先

    更多相关内容
  • 主要介绍了python实现图的深度优先搜索和广度优先搜索相关知识点,对此有兴趣的朋友学习下。
  • 这篇文章主要介绍了python 递归深度优先搜索与广度优先搜索算法模拟实现 ,非常不错,具有一定的参考借鉴价值,需要的朋友可以参考下 一、递归原理小案例分析 (1)# 概述 递归:即一个函数调用了自身,即实现了递归 ...
  • 深度优先搜索python

    2022-05-23 20:56:39
    深度优先搜索 概念 深度优先搜索和广度优先搜索一样,都是对图进行搜索的算法,目的也都是从起点开始搜索直到到达指定顶点(终点)。深度优先搜索会沿着一条路径不断往下搜索直到不能再继续为止,然后再折返,开始...

    深度优先搜索

    概念

    深度优先搜索和广度优先搜索一样,都是对图进行搜索的算法,目的也都是从起点开始搜索直到到达指定顶点(终点)。深度优先搜索会沿着一条路径不断往下搜索直到不能再继续为止,然后再折返,开始搜索下一条候补路径。

    具体而言

    步骤1

    在这里插入图片描述
    A为起点,G为终点。一开始我们在起点A上。

    步骤2

    在这里插入图片描述
    将可以从A直达的三个顶点B、C、D设为下一步的候补顶点。

    步骤3

    在这里插入图片描述
    从候补顶点中选出一个顶点。优先选择最新成为候补的点,如果几个顶点同时成为候补,那么可以从中随意选择一个。

    步骤4

    在这里插入图片描述
    此处B、C、D同时成为候补,所以我们随机选择了最左边的顶点。

    步骤5

    在这里插入图片描述
    移动到选中的顶点B。此时我们在B上,所以B变为红色,同时将已经搜索过的顶点变为橙色。

    步骤6

    在这里插入图片描述
    将可以从B直达的两个顶点E和F设为候补顶点。

    步骤7

    在这里插入图片描述
    此时,最新成为候补顶点的是E和F,我们选择了左边的顶点E。

    步骤8

    在这里插入图片描述
    移动到选中的顶点E上。

    步骤9

    在这里插入图片描述
    将可以从E直达的顶点K设为候补顶点。

    步骤10

    在这里插入图片描述
    重复上述操作直到到达终点,或者所有顶点都被遍历为止。

    步骤11

    在这里插入图片描述
    这个示例的搜索顺序为A、B、E、K、F、C、H。

    步骤12

    在这里插入图片描述
    现在我们搜索到了顶点C。

    步骤13

    在这里插入图片描述
    到达终点G,搜索结束。

    广度优先搜索与深度优先搜索的区别

    广度优先搜索选择的是最早成为候补的顶点,因为顶点离起点越近就越早成为候补,所以会从离起点近的地方开始按顺序搜索;而深度优先搜索选择的则是最新成为候补的顶点,所以会一路往下,沿着新发现的路径不断深入搜索。

    代码

    题目

    剑指offer55_二叉树的深度
    题目描述:
    输入一棵二叉树的根节点,求该树的深度。从根节点到叶节点依次经过的节点(含根、叶节点)形成树的一条路径,最长路径的长度为树的深度。
    例如:

    给定二叉树 [3,9,20,null,null,15,7],

    在这里插入图片描述
    返回它的最大深度 3 。

    # Definition for a binary tree node.
    # class TreeNode:
    #     def __init__(self, x):
    #         self.val = x
    #         self.left = None
    #         self.right = None
    # 深度优先搜索
    class Solution:
        def maxDepth(self, root):
            if root is None: 
                return 0 
            else: 
                left_height = self.maxDepth(root.left) 
                right_height = self.maxDepth(root.right) 
                return max(left_height, right_height) + 1 
    
    
    展开全文
  • 深度优先搜索算法(Depth-First-Search,DFS)是一种用于遍历或搜索树或图的算法。沿着树的深度遍历树的节点,尽可能深的搜索树的分支。当节点 v 的所在边都己被探寻过,搜索将回溯到发现节点 v 的那条边的起始节点...

    资源下载地址:https://download.csdn.net/download/sheziqiong/85683069
    资源下载地址:https://download.csdn.net/download/sheziqiong/85683069

    1 深度优先遍历搜索(DFS)

    1.1 算法介绍

    深度优先搜索算法(Depth-First-Search,DFS)是一种用于遍历或搜索树或图的算法。沿着树的深度遍历树的节点,尽可能深的搜索树的分支。当节点 v 的所在边都己被探寻过,搜索将回溯到发现节点 v 的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点,则选择其中一个作为源节点并重复以上过程,整个进程反复进行直到所有节点都被访问为止。属于盲目搜索。

    在这里插入图片描述

    以上图为例,简述 DFS 的过程。首先从根节点“1”出发,按一定的顺序遍历其子节点,这里我们假设优先遍历左边的。所以,在遍历“1”之后,我们到了节点“2”,此时“2”仍有子节点,所以应继续向下遍历,下一个节点是“3”,然后是“4”。到了“4”之后,没有子节点了,说明我们已经将这一条路遍历完了,接着我们应该回溯,应该回到“4”的父节点,也就是“3”。因为“3”还有一个子节点“5”没有遍历,所以下一个我们应该遍历的是“5”。遍历完“5”之后又发现一条路到头了,再次回溯依然回溯到其父节点“3”,此时“3”的所有子节点都已经遍历完了,因该接着回溯到“3”的父节点“2”,然后检查“2”是否有没有遍历完的子节点。按照这样的规则,完成所有节点的遍历。最终得到的遍历顺序是“1-2-3-4-5-6-7-8-9-10-11-12”

    在介绍了 DFS 在遍历树的应用后,我们将其应用于八数码问题的解决。八数码问题也称为九宫问题。在 3×3 的棋盘,摆有八个棋子,每个棋子上标有 1 至 8 的某一数字,不同棋子上标的数字不相同。棋盘上还有一个空格,与空格相邻的棋子可以移到空格中。要求解决的问题是:给出一个初始状态和一个目标状态,找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。所谓问题的一个状态就是棋子在棋盘上的一种摆法。棋子移动后,状态就会发生改变。解八数码问题实际上就是找出从初始状态到达目标状态所经过的一系列中间过渡状态。

    上面说的 DFS 遍历的树是已经存在的,我们只需要按照规定的遍历方法就能完成遍历,而对于八数码问题,没有已经存在的路径供我们遍历,需要我们从初始状态向下延伸(也就是上下左右移动)才能构造出类似的树。
    在这里插入图片描述

    以上图为例。在使用 DFS 进行搜索时,每个状态都会按照一定的顺序进行上下左右移动(在上图中是下、左、右、上的顺序),一次移动后会产生一个新的状态,然后以新状态为起点继续按约定的顺序(例如先向下)移动。终止的条件是找到解或者达到深度界限。那么如果按照图中下、左、右、上的顺序搜索后的结果将会是最左边的一条路一直是优先向下移动,如果不能向下则依次会是左、右、上的一种。

    1.2 实验结果

    以下面这个八数码为例,用 DFS 进行搜索。

    在这里插入图片描述

    将找出的解从初始状态一步一步输出到解状态。

    可以看出总共进行了 15 次遍历,在某一条路的第 4 层找到了解。

    下面我们来看一看 DFS 的所有 15 次遍历,以此来更深入的理解 DFS 的原理。稍微对代码进行改动,使其输出遍历次数和当前层数。由于结果太长,为了方便展示,下面将以树的形式展示。

    上面输出的解就是按照红色路线标注找到的,从遍历次数可以看出 DFS 是一条道走到黑的找法,因为设置的深度界限是 4,所以每一条路最多找到第 4 层。

    资源下载地址:https://download.csdn.net/download/sheziqiong/85683069
    资源下载地址:https://download.csdn.net/download/sheziqiong/85683069

    展开全文
  • 一、递归原理小案例分析 (1)# 概述 递归:即一个函数调用了自身,即实现了递归 凡是循环能做到的事,递归一般都能做到! (2)# 写递归的过程 1、写出临界条件 2、找出这一次和上一次关系 3、假设当前函数已经能用...
  • 深度优先搜索-Python

    2022-04-12 11:28:25
    深度优先遍历图的方法是,从图中某顶点v出发: (1)访问顶点v; (2)依次从v的未被访问的邻接点出发,对图进行深度优先遍历;直至图中和v有路径相通的顶点都被访问; (3)若此时图中尚有顶点未被访问,则从一个未...

    基本思路:
    深度优先遍历图的方法是,从图中某顶点v出发:
    (1)访问顶点v;
    (2)依次从v的未被访问的邻接点出发,对图进行深度优先遍历;直至图中和v有路径相通的顶点都被访问;
    (3)若此时图中尚有顶点未被访问,则从一个未被访问的顶点出发,重新进行深度优先遍历,直到图中所有顶点均被访问过为止。

    例1:图像渲染
    图像渲染
    输入: image = [[1,1,1],[1,1,0],[1,0,1]],sr = 1, sc = 1, newColor = 2
    输出: [[2,2,2],[2,2,0],[2,0,1]]
    解析: 在图像的正中间,(坐标(sr,sc)=(1,1)),在路径上所有符合条件的像素点的颜色都被更改成2。
    注意,右下角的像素没有更改为2,因为它不是在上下左右四个方向上与初始点相连的像素点。

    class Solution:
        def floodFill(self, image: List[List[int]], sr: int, sc: int, newColor: int) -> List[List[int]]:
            oldColor = image[sr][sc]
            if oldColor == newColor:
                return image
            def dfs(image,i,j):
                if i < 0 or i > len(image)-1 or j < 0 or j > len(image[0])-1 or image[i][j] != oldColor:
                    return
                image[i][j] = newColor
                dfs(image,i+1,j)
                dfs(image,i-1,j)
                dfs(image,i,j+1)
                dfs(image,i,j-1)
                return image
            return dfs(image,sr,sc)
    

    例2:岛屿数量
    给一个01矩阵,1代表是陆地,0代表海洋, 如果两个1相邻,那么这两个1属于同一个岛。我们只考虑上下左右为相邻。
    岛屿: 相邻陆地可以组成一个岛屿(相邻:上下左右) 判断岛屿个数。
    例如:
    输入
    [
    [1,1,0,0,0],
    [0,1,0,1,1],
    [0,0,0,1,1],
    [0,0,0,0,0],
    [0,0,1,1,1]
    ]
    对应的输出为3

    class Solution:
        def maxNumOfIsland(self , grid: List[List[int]]) -> int:
            def dfs(grid,i,j):
                if i < 0 or j < 0 or i >= len(grid) or j >= len(grid[0]) or grid[i][j] == 0:
                    return
                grid[i][j] = 0
                dfs(grid,i+1,j)
                dfs(grid,i-1,j)
                dfs(grid,i,j+1)
                dfs(grid,i,j-1)           
            island = 0
            for i in range(len(grid)):
                for j in range(len(grid[0])):
                    if grid[i][j] == 1:
                        island += 1
                        dfs(grid,i,j)
            return island
    

    例3:岛屿最大面积
    岛屿最大面积
    输入:grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,0,0,0,0,0,0,1,1,0,0,0,0]]
    输出:6
    解释:答案不应该是 11 ,因为岛屿只能包含水平或垂直这四个方向上的 1 。

    class Solution:
        def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
            max_island = 0
            def dfs(grid,i,j,res):
                if i < 0 or i > len(grid)-1 or j < 0 or j > len(grid[0])-1 or grid[i][j] == 0:
                    return res
                res += grid[i][j]
                grid[i][j] = 0
                res = dfs(grid,i+1,j,res)
                res = dfs(grid,i-1,j,res)
                res = dfs(grid,i,j+1,res)
                res = dfs(grid,i,j-1,res)
                return res
            for i in range(len(grid)):
                for j in range(len(grid[0])):
                    if grid[i][j] == 1:
                        max_island = max(max_island,dfs(grid,i,j,0))
            return max_island
    
    展开全文
  • 主要介绍了python图的深度优先和广度优先算法,结合实例形式分析了图的深度优先算法与广度优先算法相关概念、原理、实现技巧与操作注意事项,需要的朋友可以参考下
  • 采用图搜索算法, 是解决骑士周游问题最 容易理解和编程的方案之一 解决方案还是分为两步: 首先将合法走棋次序表示为一个图 采用图搜索算法搜寻一个长度为(行×列-1)的路径,路径上包含每个顶点恰一次 (1)...
  • 主要介绍了Python数据结构与算法之图的广度优先与深度优先搜索算法,结合实例形式分析了图的广度优先与深度优先搜索算法原理与相关实现技巧,需要的朋友可以参考下
  • Python实现 宽度/广度优先搜索算法, 深度优先搜索算法1. 二叉树图2. 宽度/广度优先搜索算法(Breadth First Search,BSF)3. 深度优先搜索算法4. 宽度/广度优先搜索算法实现5. 深度优先搜索算法实现6. 完整代码实现 1....
  • 全排列
  • 主要介绍了python实现树的深度优先遍历与广度优先遍历,详细分析了树的深度优先遍历与广度优先遍历原理及Python相关实现技巧,需要的朋友可以参考下
  • 从n个不同元素中任取m(m≤n)个元素,按照一定的顺序排列起来,叫做从n个不同元素中取出m个元素的一个排列。当m=n时所有的排列情况叫全排列。 公式:全排列数f(n)=n!(定义0!=1) 1 递归实现全排列(回溯思想) ...
  • 广度优先搜索和深度优先搜索是图遍历的两种算法,广度和深度的区别在于对节点的遍历顺序不同。 (因个人绘图水平有限,拿了个别人的图来) 下边我们先讲广度优先搜索: 广度优先最有用的性质是可以遍历一次就生成...
  • 这篇文章主要给大家介绍了关于python迷宫问题深度优先遍历的相关资料,深度优先搜索算法(Depth-First-Search),是搜索算法的一种,需要的朋友可以参考下 一、迷宫介绍 用python解迷宫问题,迷宫是一个二维列表,本次...
  • DFS(深度优先搜索):是一种对图进行搜索的算法。 借助栈:先进后出的性质实现 深度优先搜索会沿着一条路径不断往下搜索直到不能再继续为止,然后再折返,开始搜索下一条候补路径。 定义一个图: graph = { "A":["B...
  • python数据结构与算法练习-栈解决迷宫问题深度优先搜索 深度优先搜索 将迷宫表示为如下矩阵,1表示此路不通,0表示可行,起始位置A为迷宫的 [1][1] 位置,终点S为[8][8],求一条从A到S的通路。 思路: 构建四个...
  • Python深度优先解决八数码问题

    千次阅读 热门讨论 2020-10-26 10:19:18
    在宽度优先解决八数码问题的基础上对节点类增加深度属性 import copy import numpy as np from datetime import datetime # 字符串列表化 def string_to_ls(str): return [i.split(' ') for i in str.split(',')]...
  • 基于python深度优先搜索算法DFS设计与实现
  • 实验目的:了解和掌握深度优先和宽度优先算法的原理以及应用并实现两种算法。实验内容:1.算法原理首先,我们给定一个二叉树图如下:1). 宽度优先搜索:宽度优先搜索算法(Breadth First Search,BSF),思想是:·1....
  • python 实现深度优先搜索(DFS)

    万次阅读 2019-06-08 13:04:50
    深度优先算法(DFS 算法)是什么? 寻找起始节点与目标节点之间路径的算法,常用于搜索逃出迷宫的路径。主要思想是,从入口开始,...当然,深度优先算法,只要查找到一条行得通的路径,就会停止搜索;也就是说只要有...
  • 广度优先搜索(breadth-first search, BFS) 首先,BFS可以解决两种问题 从节点A出发,能不能到节点X? 从节点A出发,到节点X的最短路径是哪条? 如何理解广度: 假如现在你需要在你的朋友的关系网中,...
  • 适用范围: 无权重的图,与深度优先搜索相比,深度优先搜索法占内存少但速度较慢,广度优先搜索算法占内存多但速度较快 复杂度: 时间复杂度为O(V+E),V为顶点数,E为边数 思路 广度优先搜索是以层为顺序,将某一层上...
  • 适用范围: 无权重的图,与深度优先搜索相比,深度优先搜索法占内存少但速度较慢,广度优先搜索算法占内存多但速度较快 复杂度: 时间复杂度为O(V+E),V为顶点数,E为边数 思路 广度优先搜索是以层为顺序,将某一层...
  • 深度优先搜索(DFS):对每一个可能的分支路径深入到不能再深入为止,而且每个节点只能访问一次。 举例:         上图是一个无向图,如果从A点发起深度优先搜索(以下的访问次序并不是唯一的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,466
精华内容 6,986
关键字:

python深度优先搜索