Leetcode DFS知识点总结

最新推荐文章于 2022-05-20 21:21:01 发布
最新推荐文章于 2022-05-20 21:21:01 发布
阅读量2k 收藏 7
点赞数
分类专栏： python leetcode DFS 面试 机试 Leetcode-Solution
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tinkle181129/article/details/79840542
版权
python 同时被 3 个专栏收录
152 篇文章 1 订阅
订阅专栏
leetcode
136 篇文章 0 订阅
订阅专栏
面试
33 篇文章 0 订阅
订阅专栏

Depth-first-search

class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root: return 0
        return max(self.maxDepth(root.left),self.maxDepth(root.right))+1
class Solution(object):
    def maxAreaOfIsland(self, grid):
        """
        :type grid: List[List[int]]
        :rtype: int
        """
        m = len(grid)
        if m == 0: return 0
        n = len(grid[0])
        disvisited = [[True for j in range(n)] for i in range(m)]

        def dfs(ii,jj):
            ret = 0
            dx = [0,0,-1,1]
            dy = [1,-1,0,0]
            for k in range(4):
                x = ii + dx[k]
                y = jj + dy[k]
                if x>=0 and x<m and y>=0 and y<n and disvisited[x][y] and grid[x][y]:
                    disvisited[x][y] = False
                    ret = ret+1+dfs(x,y)
            return ret

        maxret = 0
        for i in range(m):
            for j in range(n):
                if disvisited[i][j] and grid[i][j]:
                    disvisited[i][j] = False
                    cnt = 1 + dfs(i,j)
                    maxret = max(maxret,cnt)
        return maxret
class Solution(object):
    def getImportance(self, employees, id):
        """
        :type employees: Employee
        :type id: int
        :rtype: int
        """
        emp = dict()
        visited = dict()
        for employee in employees:
            emp[employee.id] = employee
        def dfs(idx):
            if idx in visited:
                return 0
            visited[idx] = True
            ret=emp[idx].importance
            for sub in emp[idx].subordinates:
                ret+=dfs(sub)
            return ret
        return dfs(id)
  • 733. Flood Fill：从出发点(sr,sc)开始，与之相连的有相同像素的点都换成newColor, Easy
class Solution(object):
    def floodFill(self, image, sr, sc, newColor):
        """
        :type image: List[List[int]]
        :type sr: int
        :type sc: int
        :type newColor: int
        :rtype: List[List[int]]
        """
        m = len(image)
        if m == 0: return image
        n = len(image[0])
        disvisited = [[True for j in range(n)] for i in range(m)]
        rawColor = image[sr][sc]

        def dfs(xx,yy):
            disvisited[xx][yy] = False
            image[xx][yy] = newColor
            dx = [0,0,-1,1]
            dy = [1,-1,0,0]
            for k in range(4):
                x = xx+dx[k]
                y = yy+dy[k]
                if x>=0 and x<m and y>=0 and y<n and disvisited[x][y] and image[x][y]==rawColor:
                    dfs(x,y)
        dfs(sr,sc)
        return image

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution(object):
    def isSameTree(self, p, q):
        """
        :type p: TreeNode
        :type q: TreeNode
        :rtype: bool
        """
        if p is None and q is None:
            return True
        elif p is None or q is None:
            return False
        else:
            if p.val==q.val:
                if self.isSameTree(q.left,p.left):
                    return self.isSameTree(p.right,q.right)
            return False
  • 108. Convert Sorted Array to Binary Search Tree：把一个有序列表转化为二叉搜索树，Easy
    根据二叉搜索树的性质，左树上的值<根结点的值<右树上的值
    因此可以取 nums/2 位置上的值作为根结点的值，然后再左右递归调用即可 
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def sortedArrayToBST(self, nums):
        """
        :type nums: List[int]
        :rtype: TreeNode
        """
        length = len(nums)
        if length==0:
            return None
        if length == 1:
            return TreeNode(nums[0])
        root = TreeNode(nums[length/2])
        root.left = self.sortedArrayToBST(nums[:(length/2)])
        root.right =self.sortedArrayToBST(nums[(length/2+1):])
        return root
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if root==None:
            return True
        return self.symetric(root.left,root.right)
    def symetric(self,root_a,root_b):
        if root_a==None and root_b==None:
            return True
        if root_a==None or root_b==None:
            return False
        if root_a.val !=root_b.val:
            return False
        return self.symetric(root_a.left,root_b.right) and self.symetric(root_a.right,root_b.left)
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def binaryTreePaths(self, root):
        """
        :type root: TreeNode
        :rtype: List[str]
        """
        ret = []
        if root == None:
            return ret
        cur_val = root.val
        if root.left:
            ret += self.binaryTreePaths(root.left)
        if root.right:
            ret += self.binaryTreePaths(root.right)
        if ret == []:
            return [str(cur_val)]
        else:
            for i in range(len(ret)):
                ret[i] = str(cur_val)+'->'+ret[i]
            return ret
  • 110. Balanced Binary Tree：判断二叉树是否是平衡二叉树，Easy
    左子树是否平衡+右子树是否平衡+左右子树的高度差<=1 
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def height(self,root):
        if root == None:
            return 0
        if root.left == None and root.right == None:
            return 1
        return max(self.height(root.left),self.height(root.right))+1

    def isBalanced(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if root ==None:
            return True
        return self.isBalanced(root.left) and self.isBalanced(root.right) and abs(self.height(root.left)-self.height(root.right))<=1
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if root == None:
            return 0
        if root.left == None and root.right !=None:
            return self.minDepth(root.right)+1
        if root.right == None and root.left !=None:
            return self.minDepth(root.left)+1
        return min(self.minDepth(root.left),self.minDepth(root.right))+1
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def findBottomLeftValueDFS(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if root == None: return 0
        def dfs(root,step):
            maxstep = step
            val = root.val
            if root.left:
                leftstep,lval = dfs(root.left,step+1)
                if leftstep>maxstep:
                    maxstep = leftstep
                    val = lval
            if root.right:
                rightstep,rval = dfs(root.right,step+1)
                if rightstep>maxstep:
                    maxstep = rightstep
                    val = rval
            return maxstep,val
        maxstep,val = dfs(root,0)
        return val
    def findBottomLeftValueBFS(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if root == None: return 0
        queue = [root]
        while(queue):
            tmp = []
            for q in queue:
                if q.left:
                    tmp.append(q.left)
                if q.right:
                    tmp.append(q.right)
            if tmp == []:
                return queue[0].val
            queue = tmp[:]
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def largestValues(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        steps = dict()
        def dfs(root,step):
            if root is None:
                return 
            if step not in steps:
                steps[step] = root.val
            else:
                steps[step] = max(steps[step],root.val)
            if root.left:
                dfs(root.left,step+1)
            if root.right:
                dfs(root.right,step+1)
        dfs(root,0)
        ans = sorted(steps.items(),key=lambda x:x[0])
        ret = list(map(lambda x:x[1],ans))

        return ret

    def largestValuesBFS(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if root is None: return []
        queue = [root]
        ret = []
        while(queue):
            tmp = []
            val = None
            for q in queue:
                if q.left:
                    tmp.append(q.left)
                if q.right:
                    tmp.append(q.right)
                if val is None: val = q.val
                else:
                    val = max(val,q.val)
            queue = tmp[:]
            ret.append(val)
        return ret
  • 529. Minesweeper 扫雷游戏，如果东西南北加对角线没有雷的话，则标记为’B’，同时沿着8个方向递归；如果东西南北加对角线有雷的话，则标记为’E’；如果踩到雷的话，则标记为’X’, Medium
class Solution(object):
    def updateBoard(self, board, click):
        """
        :type board: List[List[str]]
        :type click: List[int]
        :rtype: List[List[str]]
        """
        m = len(board)
        if m == 0: return board
        n = len(board[0])
        if board[click[0]][click[1]] == 'M':
            board[click[0]][click[1]] = 'X'
            return board
        disvisited = [[True for j in range(n)] for i in range(m)]
        def dfs(i,j):
            disvisited[i][j] = False
            dx = [1,1,1,0,0,-1,-1,-1]
            dy = [0,1,-1,1,-1,0,1,-1]
            flag = 0
            for k in range(8):
                x = dx[k]+i
                y = dy[k]+j
                if x>=0 and x<m and y>=0 and y<n:
                    if board[x][y] == 'M':
                        flag +=1
            if flag: board[i][j] = str(flag)
            else:
                board[i][j] = 'B'
                for k in range(8):
                    x = dx[k]+i
                    y = dy[k]+j
                    if x>=0 and x<m and y>=0 and y<n and disvisited[x][y]:
                        dfs(x,y)
        dfs(click[0],click[1])
        return board


  • 486. Predict the Winner给定一个数组，玩家只能从两端取数，判断第一个玩家取数之和是否能够大于第二个玩家，Medium

dfs+记忆化搜索 

class Solution(object):
    def PredictTheWinner(self, nums):
        """
        :type nums: List[int]
        :rtype: bool
        """
        cache = dict()
        def dfs(tnums):
            if len(tnums)<=1: return sum(tnums)
            tnums = tuple(tnums)
            if tnums in cache: return cache[tnums]
            ans = max(tnums[0]-dfs(tnums[1:]),tnums[-1]-dfs(tnums[:-1]))
            cache[tnums] = ans
            return cache[tnums] 
        return dfs(nums)>=0
  • 638. Shopping Offers 购买不同产品有不同的单价花费，同时也提供组合套餐，问购买指定组数目产品所需的最少费用
class Solution(object):
    def shoppingOffers(self, price, special, needs):
        """
        :type price: List[int]
        :type special: List[List[int]]
        :type needs: List[int]
        :rtype: int
        """
        dp = dict()
        def dfs(tup):
            if tup in dp:
                return dp[tup]
            dp[tup]=sum([t*p for t,p in zip(tup,price)])
            for sp in special:
                new_tup = tuple([t-st for t,st in zip(tup,sp)])
                if min(new_tup)<0:
                    continue
                dp[tup] = min(dp[tup], dfs(new_tup) + sp[-1])
            return dp[tup]
        return dfs(tuple(needs))

to be continue

ep_mashiro
关注
专栏目录
Leetcode DFS系列算法回顾和总结
Ricardo Wang
09-02 626
刷LeetCode一定要总结，不然就是走马观花，很难体会到其中的精髓 DFS系列的算法相比其他算法，本人是觉得是相对比较抽象的。其他的算法，比如动态规划，排序等，只要处理好每一步的处理结构就能很好的完成算法的设计和实现。但是DFS算法需要比较高的抽象能力，不光要处理每一步的流程，还要兼顾每一次迭代对其他迭代的影响，因为在设置迭代单元的时候，需要很好的界定功能边界。 LeeTcode...
LeetCode刷题经验帖总结
qq_38025771的博客
02-15 1413
目录一、大家都是如何刷 LeetCode 的？二、LeetCode大佬经验 一、大家都是如何刷 LeetCode 的？ 大家都是如何刷 LeetCode 的？ 建议优先按题目tag刷题 边做边根据题目总结算法模板和套路 前300道，尽量能刷两遍，大部分题目代码量控制在50行以内，能够bug free且快速地写出常用的代码块（比如union find, dfs/bfs几个变种, binary search, partition等等） 尽量选用更简单的数据结构，缩短运行时间，化繁为简。能用vec
DFS知识点
weixin_30563319的博客
06-01 113
2019-06-01 11:14:34 加油，坚持！！！ 1. 2. 3. 转载于:https://www.cnblogs.com/Artimis-fightting/p/10960409.html
leetcode DFS
StubbornAnt的博客
11-11 563
leetcode 排列组合Permutation Combinations
【LeetCode】DFS 总结
weixin_30765475的博客
04-18 121
DFS（深度优先搜索） 常用来解决可达性的问题。 两个要点： 栈：用栈来保存当前节点信息，当遍历新节点返回时能够继续遍历当前节点。可以使用递归栈。 标记：和 BFS 一样同样需要对已经遍历过的节点进行标记。 695. 岛屿的最大面积 题目描述 给定一个包含了一些 0 和 1的非空二维数组 grid , 一个 岛屿 是由四个方向 (水平或垂直) 的 1 (代表土地) 构成的组合。你可以假设...
leetcode DFS 问题总结
weixin_34194702的博客
08-08 82
TODO。。。。
leetcode分类-LeetCode:个人刷LeetCode题目的归纳总结
06-30
这个"leetcode分类-LeetCode:个人刷LeetCode题目的归纳总结"是某位用户对他在LeetCode上刷题的经验和心得的整理，分为不同的主题类别，让我们逐一探讨这些知识点。 1. **数组**：数组是最基本的数据结构之一，...
leetcode分类-leetcode:Leetcode题目分类总结，附题解及思路
06-30
本文将围绕LeetCode题目进行分类总结，并分享解题思路，旨在帮助读者深入理解并掌握这些知识点。 一、数组与矩阵 数组是最基础的数据结构之一，LeetCode中涉及的数组题目包括单数组操作、双数组操作、多维数组...
leetcode数据结构的一些总结
最新发布
04-14
这里我们主要关注“数据结构”的部分，尤其是通过LeetCode学习和总结的数据结构知识点。 首先，数据结构是计算机科学的基础，它是组织、管理和存储数据的方式，直接影响着程序的效率和可读性。在LeetCode上，常见的...
【LeetCode 总结】Leetcode 题型分类总结、索引与常用接口函数
只能说希望每日一更
08-07 3179
文章目录零. Java 常用接口函数集合类数学类字符串一. 动态规划知识点题目二. 链表知识点题目三. 哈希表知识点题目四. 滑动窗口知识点题目五. 字符串知识点题目六. DFS、BFS知识点题目七. 二分法知识点题目八. 偏数学、过目不忘 and 原地算法等知识点题目 前言： 是时候开一个对于我的 LeetCode 专栏的总结索引了= = 虽然说大概只刷了150道左右，不过应该也可以简单总结一下了呢～ 题型主要是 LeetCode hot100 + 剑指Offer，也有其他的一些高频题 零. Java
[leetcode][dfs]深度优先搜索算法总结
wonner_的博客
03-03 657
dfs算法通常使用递归实现，逻辑清晰。在递归开头写一个跳出条件，然后继续向下递归遍历即可。要用一个额外的空间记录节点访问情况，遍历过的地方不再遍历，防止陷入循环，或者在原空间上进行修改。下面给出图上的dfs算法实现，与树有关的算法在树的博客中单独总结。 200.岛屿数量 给定一个由'1'（陆地）和 '0'（水）组成的的二维网格，计算岛屿的数量。一个岛被水包围，并且它是通过水平方向或垂直方向上...
leetcode-深度优先搜索总结（DFS）
Less is More
04-06 233
TODO------------
leetcode刷题总结-DFS
qq_35154223的博客
03-04 177
回溯法（深度优先搜索） 回溯法按深度优先搜索 搜索问题的解空间树。首先从根节点出发搜索解空间树，当算法搜索至解空间树的某一节点时，先利用剪枝函数 判断该节点是否可行。如果不可行，则跳过对该节点为根的子树搜索，逐层向其祖先节点回溯；否则，进入该子树，继续按深度优先策略搜索。 示例： leetcode第22题： 给出 n 代表生成括号的对数，请你写出一个函数，使其能够生成所有可能的并且有效的括号组合。...
Leetcode 链表知识点总结
大锅八十小锅四十
02-17 1057
来看下Leetcode中Tag为[ Linked-List ]（https://leetcode.com/tag/linked-list/ ）的题目[ 141. Linked List Cycle ]（https://leetcode.com/problems/linked- list-cycle / description / ）：判断一个链表是否存在环，Easy [ 142.链接列表循环II ...
Leetcode 栈知识点总结
大锅八十小锅四十
03-07 835
来看下Leetcode中Tag为Stack的题目 [Leetcode 739] Daily Temperatures：求下一个温暖天气距离当前日期的时间差。Medium class Solution(object): def dailyTemperatures(self, temperatures): """ :type temperatures...
LeetCode【DFS】
耀的博客
05-20 487
/* 回溯算法思路 */ LinkedList<Integer> res = new LinkedList<>(); // 返回前序遍历结果 public List<Integer> inorderTraversal2(TreeNode root) { traverse(root); return res; } // 二叉树遍历函数 void traverse(TreeNode ...
DFS 知识点以及模板题
ACM-ICPC 现役(铜牌) Codeforces Rating: 2172
08-20 292
DFS —— 不撞南墙不回溯 —— 死脑筋 BFS —— 眼观六路耳听八方 —— 一层一层的搜索 DFS : DFS BFS stack（栈） queue（队列） O(h)O(h)O(h) O(2h)O(2^h)O(2h) 不具有最短路性质 具有最短路性质
LeetCode刷题遇到的小知识点总结
一名小码农的博客
12-13 959
刷题遇到的小知识点，在这里做个笔记，主要是记录想法、理解、一些牛逼的操作、没见过的算法、数据结构。使用的语言为java。（持续更新中……）
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值