leetcode中DFS与BFS算法在数组和字符串中的应用

DFS(深度优先遍历)BFS(广度优先遍历)算法是基于树和图结构进行遍历的两种算法。
一般来说DFS在前中后遍历中运用比较明显,DFS的运用基本是要利用递归进行嵌套使用。回溯算法其实也是一种比较经典的DFS算法升级运用
而BFS比较经典的运用就是层次遍历,一般会运用数组while循环不断进行popinsert操作。

涉及到回溯算法和递归的二叉树结构题,之前已经进行过总结:
leetcode回溯算法
leetcode二叉树遍历与递归题目汇总

然而,对于字符串和数组类的结构,我自己在开始的时候很难将其与DFS和BFS算法结合起来。所以为了更深入的理解DFS和BFS算法的精髓,这里针对这些数据结构进一步汇总

BFS

BFS在计算最短或者最小等问题上相比DFS要简单很多,因为找到某层符合条件的一个即可停止。
BFS在进行计算的时候常常会结合队列(deque)这种数据结构,关于队列的介绍我之前做过一个小的总结:
python双向队列deque的基本用法
也可以跟着leetcode的系列学习一下队列和算法的知识
leetcode数据结构简介:队列和栈

1.字符串匹配问题

301. 删除无效的括号
找到删除最小括号可以满足的字符串,显然是横向对比只要较高层存在一个即可,故肯定是BFS的问题。
思路:1.理解何种字符串是符合要求的,并写出isValid函数判断
2.利用filter函数对字符串进行映射判断
3.利用while循环分别判断初始字符串减去一个字符的level,二个字符的level等情况的结果情况。不停地更新每一次的level情况

class Solution:
    def removeInvalidParentheses(self, s: str) -> List[str]:
        def isValid(s):
            cnt = 0
            for i in s:
                if i == '(':
                    cnt += 1
                elif i == ')':
                    cnt -= 1
                if cnt < 0:return False
            return cnt == 0
        
        level = {
   s}
        while level:
            valid = list(filter(isValid,level))
            if valid:return valid
            next_level = set()
            for item in level:
                for i in range(len(item)):
                	#只判定为括号的情况,其他情况不需要判定
                    if item[i] in '()':
                        next_level.add(item[:i] + item[i+1:])
            level = next_level

127. 单词接龙
以最短的路径变换单词,从初始单词到目标单词。
思路:1.先生成模糊单词表;
2.基于单词表对单词进行匹配

from collections import deque

class Solution(object):
	def ladderLength(self, beginWord, endWord, wordList):

		def construct_dict(word_list):
			d = {
   }
			for word in word_list:
				for i in range(len(word)):
					s = word[:i] + "_" + word[i + 1:]
					d[s] = d.get(s, []) + [word]
			return d

		def bfs_words(begin, end, dict_words):
			queue, visited = deque([(begin, 1)]), set()
			while queue:
				word, steps = queue.popleft()
				if word not in visited:
					visited.add(word)
					if word == end:
						return steps
					for i in range(len(word)):
						s = word[:i] + "_" + word[i + 1:]
						neigh_words = dict_words.get(s, [])
						for neigh in neigh_words:
							if neigh not in visited:
								queue.append((neigh, steps + 1))
			return 0

		d = construct_dict(set(wordList))
		return bfs_words(beginWord, endWord, d)

1091. 二进制矩阵中的最短路径
逻辑与计算最大岛屿类似,但是方向改成了8个方向遍历,上下左右,左上、右上、左下、右下。
遍历的条件为:
1.如果当前索引达到最大,那么直接返回最大值;
2.如果索引没达到最大,且遍历的当前值为0(畅通),则将其改为1.

class Solution:
    def shortestPathBinaryMatrix(self, grid: List[List[int]]) -> int:
        n = len(grid)
        if not grid or grid[0][0] == 1 or grid[n-1][n-1] == 1:
            return -1
        elif n <= 2:
            return n
        queue = [(0, 0, 1)]
        grid[0][0] = 1
        while queue:
            i, j, step = queue.pop(0)           
            for dx, dy in [(-1,-1), (1,0), (0,1), (-1,0), (0,-1), (1,1), (1,-1), (-1,1)]:
                if i+dx == n-1 and j+dy == n-1:
                    return step + 1
                if 0 <= i+dx < n and 0 <= j+dy < n and grid[i+dx][j+dy] == 0:
                    queue.append((i+dx, j+dy, step+1))
                    grid[i+dx][j+dy] = 1  # mark as visited                   
        return -1

DFS

1.数组问题

数组问题,尤其是岛屿的一系列问题是运用DFS算法计算的典型问题。这里列举一些岛屿问题。
6.岛屿的最大面积
典型的数组中的最大值问题,需要遍历每个单元找到最大值,故是DFS问题。

class Solution:
    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
    	#用res[0]代表全局最大值,res[1]代表局部最大值
    	#确定初始参数
        res,r,c = [0,0],len(grid),len(grid[0])
        #定义dfs函数
        def f(i,j):
            res[1] 
  • 1
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值