BFS——广度优先算法(Breadth First Search)
BFS适用于解决:给定初始状态跟目标状态,要求从初始状态到目标状态的最短路径。
【算法入门】深度优先搜索(DFS)
宽度优先搜索
什么时候用宽度优先搜索
Depth-First Search and Breadth-First Search in Python
graph = {'A': set(['B', 'C']),
'B': set(['A', 'D', 'E']),
'C': set(['A', 'F']),
'D': set(['B']),
'E': set(['B', 'F']),
'F': set(['C', 'E'])}
def bfs(graph,start):
visited=set()
queue=[start]
while queue:
vertex=queue.pop(0)
if vertex not in visited:
visited.add(vertex)
queue.extend(graph[vertex]-visited)
return visited
bfs(graph, 'A') # {'B', 'C', 'A', 'F', 'D', 'E'}
二叉树上的宽度优先搜索
Binary Level Order Traversal
class Solution:
def levelOrder(self, root):
"""
:type root: TreeNode
:rtype: List[List[int]]
"""
if not root:
return []
queue=[]
res=[]
queue.append(root)
while queue:
size=len(queue)
level=[]
for i in range(size):
node=queue.pop(0)
level.append(node.val)
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
res.append(level)
return res
二叉树序列化
class Solution:
"""
@param root: An object of TreeNode, denote the root of the binary tree.
This method will be invoked first, you should design your own algorithm
to serialize a binary tree which denote by a root node to a string which
can be easily deserialized by your own "deserialize" method later.
"""
def serialize(self, root):
# write your code here
if not root:
return "{}"
queue=[root]
res=[]
while queue:
node=queue.pop(0)
if node=="#":
res.append(node)
else:
res.append(str(node.val))
if node.left:
queue.append(node.left)
else:
queue.append("#")
if node.right:
queue.append(node.right)
else:
queue.append("#")
while res[-1]=="#":
res.pop()
return "{"+",".join(res)+"}"
"""
@param data: A string serialized by your serialize method.
This method will be invoked second, the argument data is what exactly
you serialized at method "serialize", that means the data is not given by
system, it's given by your own serialize method. So the format of data is
designed by yourself, and deserialize it here as you serialize it in
"serialize" method.
"""
def deserialize(self, data):
# write your code here
if len(data)<=2:
return
lst=data[1:-1].split(",")
isleftchild=True
root=TreeNode(int(lst[0]))
queue=[]; queue.append(root)
index=0
for i in range(1,len(lst)):
if lst[i]!="#":
node=TreeNode(int(lst[i]))
if isleftchild:
queue[index].left=node
else:
queue[index].right=node
queue.append(node)
if not isleftchild:
index+=1
isleftchild=not isleftchild
return root
Graph valid tree
一个图是不是一个树:
有n-1条边,连通
Solution:
use BFS to visit the graph, if encountered the vertice that just been visited, or when finished visiting, there are still nodes that has not been visited, then this graph is not a valid tree.
class Solution:
def validTree(self, n, edges):
"""
:type n: int
:type edges: List[List[int]]
:rtype: bool
"""
graph={i:set() for i in range(n)}
for i, j in edges: #contruct graph
graph[i].add(j)
graph[j].add(i)
queue=[list(graph.keys())[0]]
visited=set()
while queue:
vertex=queue.pop(0)
if vertex in visited:
return False
else:
visited.add(vertex)
queue.extend(graph[vertex]-visited)
graph.pop(vertex)
return not graph #all nodes have been visited
Clone graph
# Definition for a undirected graph node
# class UndirectedGraphNode:
# def __init__(self, x):
# self.label = x
# self.neighbors = []
class Solution:
# @param node, a undirected graph node
# @return a undirected graph node
def cloneGraph(self, node):
if not node:
return
queue=[node]
newnode=UndirectedGraphNode(node.label)
visited={node:newnode}
while queue:
vertex=queue.pop(0)
for neighbor in vertex.neighbors:
if neighbor not in visited:
new=UndirectedGraphNode(neighbor.label)
visited[neighbor]=new
visited[vertex].neighbors.append(new)
queue.append(neighbor)
else:
visited[vertex].neighbors.append(visited[neighbor])
return newnode
深度优先搜索
graph = {'A': set(['B', 'C']),
'B': set(['A', 'D', 'E']),
'C': set(['A', 'F']),
'D': set(['B']),
'E': set(['B', 'F']),
'F': set(['C', 'E'])}
def dfs(graph,start):
visited=set()
stack=[start]
while stack:
vertex=stack.pop()
if vertex not in visited:
visited.add(vertex)
print (vertex)
stack.extend(graph[vertex]-visited)
return visited
# A B D E F C
Number of islands
class Solution(object):
def numIslands(self, grid):
"""
:type grid: List[List[str]]
:rtype: int
"""
if not grid:
return 0
cnt=0
for i in range(len(grid)):
for j in range(len(grid[0])):
if grid[i][j]=="1":
self.dfs(grid,i,j)
cnt+=1
return cnt
def dfs(self,grid,i,j):
if i<0 or j<0 or i>=len(grid) or j>=len(grid[0]) or grid[i][j]!='1':
return
grid[i][j]="#"
self.dfs(grid,i+1,j)
self.dfs(grid,i-1,j)
self.dfs(grid,i,j+1)
self.dfs(grid,i,j-1)