【每日一题】1162 地图分析（BFS,，前后两次dp）

2020.03.29
首先看到题目就能想到这是一道BFS题目（其实开始想到用动态规划）
因为对bfs的题目套路不是很熟悉没有ac。
BFS题目思路：
BFS使用队列，把每个还没有搜索到的点依次放入队列，然后再弹出队列的头部元素当做当前遍历点。BFS总共有两个模板：

1. 如果不需要确定当前遍历到了哪一层，BFS模板如下。

while queue 不空：
    cur = queue.pop()
    for 节点 in cur的所有相邻节点：
        if 该节点有效且未访问过：
        	标记节点为访问中
            queue.push(该节点)

2. 如果要确定当前遍历到了哪一层，BFS模板如下。
   这里增加了level表示当前遍历到二叉树中的哪一层了，也可以理解为在一个图中，现在已经走了多少步了。size表示在当前遍历层有多少个元素，也就是队列中的元素数，我们把这些元素一次性遍历完，即把当前层的所有元素都向外走了一步。

level = 0
while queue 不空：
    size = queue.size()
    while (size --) {
        cur = queue.pop()
        for 节点 in cur的所有相邻节点：
            if 该节点有效且未被访问过：
            	标记节点为访问中
                queue.push(该节点)
    }
    level ++;

这道题目是一个多起点的BFS，需要利用模板二，保证每次都在同一层先完成搜索。

class Solution(object):
    def maxDistance(self, grid):
        """
        :type grid: List[List[int]]
        :rtype: int
        """
        queue = []
        distance = -1
        # 查找出所有可能的源节点
        n = len(grid)
        for i in range(n):
            for j in range(n):
                if grid[i][j] == 1:
                    queue.append((i, j))
        # 特殊情况，无源或者全是源
        if len(queue) == 0 or len(queue) == n*n:
            return -1
		# ！！开始BFS
        while len(queue)>0:
            distance += 1
            # 同时弹出同一级别的
            size = len(queue)
            for i in range(size):
                r,c = queue.pop(0)
                # 上方
                if r-1>0 and grid[r-1][c] == 0:
                    grid[r-1][c] = 2  # 做标记防止3bfs出现重复
                    queue.append((r-1, c))
                ## 下方
                if r+1<n and grid[r+1][c] == 0:
                    grid[r+1][c] = 2  
                    queue.append((r+1, c))
                ##左方
                if c-1>0 and grid[r][c-1] == 0:
                    grid[r][c-1] = 2  
                    queue.append((r,c-1))
                ## 右方
                if c+1<n and grid[r][c+1] == 0:
                    grid[r][c+1] = 2  
                    queue.append((r, c+1))

        return distance

代码精妙之处：

1. BFS的代码注意细节，每次对节点的状态需要明确，未访问，已访问，访问中（本身已入列，但是邻居还没考虑）
2. 每次处理清楚入列和出列的关系
3. 清楚入列的数据形式和出列查找邻居的操作要匹配

更新

确实可以动态规划，关键还是想清楚初始值如何设置。第一次没有想好。下图来自官方题解。

class Solution:
    def maxDistance(self, grid: List[List[int]]) -> int:
        n = len(grid)
        dp = [[float('Inf') for i in range(n)] for i in range(n)]
        for i in range(n):
            for j in range(n):
                if grid[i][j]:
                    dp[i][j] = 0
                    continue
                if i > 0:
                    dp[i][j] = min(dp[i-1][j]+1, dp[i][j])
                if j > 0:
                    dp[i][j] = min(dp[i][j-1]+1, dp[i][j])
        for i in range(n-1, -1 ,-1):
            for j in range(n-1, -1, -1):
                if grid[i][j]:
                    dp[i][j] = 0
                    continue
                if i < n-1:
                    dp[i][j] = min(dp[i+1][j]+1, dp[i][j])
                if j < n-1:
                    dp[i][j] = min(dp[i][j+1]+1, dp[i][j])
        ans = 0
        for i in range(n):
            for j in range(n):
                ans = max(ans, dp[i][j])
        if ans == float('inf') or ans == 0:
            return -1
        return ans

代码总结：

1. 对于dfs和bfs题目，如果只要求问最大值，没有要求给出具体的路径的话都是可以用dp方法求解的。
2. dp方法还是要考虑清楚每一次状态转移的情况，如果是每次都是min迭代，初始值应该设置inf，转移用的max，初始值设置0。