BFS

时间:2020-03-24
本文章向大家介绍BFS,主要包括BFS使用实例、应用技巧、基本知识点总结和需要注意事项,具有一定的参考价值,需要的朋友可以参考一下。

102. 二叉树的层次遍历

难度中等

给定一个二叉树,返回其按层次遍历的节点值。 (即逐层地,从左到右访问所有节点)。

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

    3
   / \
  9  20
    /  \
   15   7

返回其层次遍历结果:

[
  [3],
  [9,20],
  [15,7]
]
 1 # Definition for a binary tree node.
 2 # class TreeNode:
 3 #     def __init__(self, x):
 4 #         self.val = x
 5 #         self.left = None
 6 #         self.right = None
 7 
 8 from collections import deque
 9 class Solution:
10     def levelOrder(self, root: TreeNode) -> List[List[int]]:
11         if not root:
12             return []
13         res = list()
14         queue = deque()
15         queue.append(root)
16         
17         while queue:
18             queue_size = len(queue)
19             temp_res = list()
20             for _ in range(queue_size):
21                 temp_node = queue.popleft()
22                 temp_res.append(temp_node.val)
23                 if temp_node.left:
24                     queue.append(temp_node.left)
25                 if temp_node.right:
26                     queue.append(temp_node.right)
27             res.append(temp_res)
28 
29         return res
View Code

103. 二叉树的锯齿形层次遍历

难度中等

给定一个二叉树,返回其节点值的锯齿形层次遍历。(即先从左往右,再从右往左进行下一层遍历,以此类推,层与层之间交替进行)。

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

    3
   / \
  9  20
    /  \
   15   7

返回锯齿形层次遍历如下:

[
  [3],
  [20,9],
  [15,7]
]
 1 # Definition for a binary tree node.
 2 # class TreeNode:
 3 #     def __init__(self, x):
 4 #         self.val = x
 5 #         self.left = None
 6 #         self.right = None
 7 from collections import deque
 8 class Solution:
 9     def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:
10         if not root:
11             return []
12         res = list()
13         queue = deque()
14         queue.append(root)
15         flag = True
16         while queue:
17             queue_size = len(queue)
18             temp_res = list()
19             for _ in range(queue_size):
20                 temp_node = queue.popleft()
21                 temp_res.append(temp_node.val)
22                 if temp_node.left:
23                     queue.append(temp_node.left)
24                 if temp_node.right:
25                     queue.append(temp_node.right)
26             if flag:
27                 res.append(temp_res)
28                 flag = False
29             else:
30                 res.append(temp_res[::-1])
31                 flag = True
32 
33         return res
View Code

127. 单词接龙

难度中等

给定两个单词(beginWord 和 endWord)和一个字典,找到从 beginWord 到 endWord 的最短转换序列的长度。转换需遵循如下规则:

  1. 每次转换只能改变一个字母。
  2. 转换过程中的中间单词必须是字典中的单词。

说明:

  • 如果不存在这样的转换序列,返回 0。
  • 所有单词具有相同的长度。
  • 所有单词只由小写字母组成。
  • 字典中不存在重复的单词。
  • 你可以假设 beginWord 和 endWord 是非空的,且二者不相同。

示例 1:

输入:
beginWord = "hit",
endWord = "cog",
wordList = ["hot","dot","dog","lot","log","cog"]

输出: 5

解释: 一个最短转换序列是 "hit" -> "hot" -> "dot" -> "dog" -> "cog",
     返回它的长度 5。

示例 2:

输入:
beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log"]

输出: 0

解释: endWord "cog" 不在字典中,所以无法进行转换。
 1 from collections import deque
 2 class Solution:
 3     def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int:
 4         wordList = set(wordList)
 5         transform_times = 0
 6         if not wordList:
 7             return 0
 8         visited_words = set([beginWord])
 9         queue = deque([beginWord])
10 
11         while queue:
12             transform_times += 1
13             queue_length = len(queue)
14             for _ in range(queue_length):
15                 temp = queue.popleft()
16                 if temp == endWord:
17                     return transform_times
18                 for each_element in self.__get_next_words(temp):
19                     if each_element in visited_words or each_element not in wordList:
20                         continue
21                     visited_words.add(each_element)
22                     queue.append(each_element)
23         
24         return 0
25         
26  
27     def __get_next_words(self, word):
28         words = []
29         length_word = len(word)
30         for i in range(length_word):
31             left, right = word[0:i], word[i+1:length_word]
32             for char in "abcdefghigklmnopqrstuvwxyz":
33                 if char != word[i]:
34                     temp_word = left + char + right
35                     words.append(temp_word)
36         return words
View Code

279. 完全平方数

难度中等

给定正整数 n,找到若干个完全平方数(比如 1, 4, 9, 16, ...)使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。

示例 1:

输入: n = 12
输出: 3 
解释: 12 = 4 + 4 + 4.

示例 2:

输入: n = 13
输出: 2
解释: 13 = 4 + 9.

 1 class Solution:
 2     def numSquares(self, n: int) -> int:
 3         queue = list()
 4         queue.append((n, 0))
 5         visited = [False for _ in range(n)]
 6         
 7         while queue:
 8             minuend, step = queue.pop(0)
 9 
10             i = 1
11             difference = minuend - i*i
12 
13             while difference >= 0:
14                 if difference  == 0:
15                     return step+1
16                 
17                 if not visited[difference ]:
18                     queue.append((difference ,step+1))
19                     visited[difference] = True
20 
21                 i = i + 1
22                 difference = minuend - i*i
View Code

原文地址:https://www.cnblogs.com/dede-0119/p/12508984.html