广度优先搜索和深度优先搜索

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)