Given a matrix consists of 0 and 1, find the distance of the nearest 0 for each cell.
The distance between two adjacent cells is 1.
Example 1:
Input:0 0 0
0 1 0
0 0 0
Output:
0 0 0
0 1 0
0 0 0
Example 2:
Input:0 0 0
0 1 0
1 1 1
Output:
0 0 0
0 1 0
1 2 1
Note:
The number of elements of the given matrix will not exceed 10,000.
There are at least one 0 in the given matrix.
The cells are adjacent in only four directions: up, down, left and right.
翻译：
给一个非空矩阵，由0和1组成，一定有0.要求返回每个元素离0的最短距离。两个相邻元素之间的距离为1.
举例1：
输入：
0 0 0
0 1 0
0 0 0
输出：
0 0 0
0 1 0
0 0 0
因为只有中心一个1，到0的距离就是1，至于0本身距离就是0。
举例2：
输入：
0 0 0
0 1 0
1 1 1
输出：
0 0 0
0 1 0
1 2 1
很容易理解，最后一行中心的1离最近的0要走两格，所以它的距离是2，其余都很容易得出。此外：
矩阵元素个数不会超过一万。
矩阵肯定有0.
元素相邻只考虑上下左右4个方向。
思路描述：
很自然想到BFS：假如我们把所有的0放入一个双端队列（以下简称DQ），那么再遍历里面元素相邻的4格，然后依此类推即可。
那么最大的问题就是，如何避免重复遍历呢？
暴力的方法就是进入DQ前检查元素是否已经在DQ里面了，当然不推荐，因为效率太低。
另一个靠谱一点的方法就是做标记，用一个flag矩阵来记录进入DQ的元素坐标。
不过如果稍加深入地思考，就会发现其实不用这样。
首先，结果是可以用初始矩阵的，不用重新生成一个，节约空间。
这样的话，为了避免原来的1对后来的结果造成影响，我们需要对其进行处理。好在我们原本就需要把所有的0都拿出来，得先遍历一遍矩阵，所以可以顺带把原来的1变成float('inf')。
因为我们是广度遍历搜索BFS，所以第一遍搜0，第二遍遍历所有0相邻的非0元素，它们的距离不可能大于1。得益于把所有原来的1变成float('inf')，当我们看到某个元素现在是1的时候，我们就知道它已经被算过了。而且这一圈值都是1，也无所谓需要算多次，一次有效的就够了。
同理，第三遍的时候DQ里面放的就是上一次值为1的元素，其相邻元素值可能为0，1，2（过程中），float('inf')，我们当然只关心最后一个了。
也就是说，在改变了原来的值的情况下，在计算m[i][j]相邻元素x的时候，假如x的值小于或者等于m[i][j] + 1，x肯定已经被遍历过了。
简而言之，由于BFS与距离的特性，初始化（1换成无限大）之后所有非0元素只需要一次有效计算就是正确的距离。
换而言之，算过的，不是无限大的，就是遍历过的了。这样就解决了重复遍历的问题。
基于此思路，代码如下：
# Time: O(m * n)
# Space: O(m * n)
import collections
import operator
class Solution(object):
def updateMatrix(self, matrix):
deque = collections.deque([])
for i in xrange(len(matrix)):
for j in xrange(len(matrix[0])):
if matrix[i][j] == 0:
deque.append((i, j))
else:
matrix[i][j] = float('inf')
directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
while deque:
e = deque.popleft()
for d in directions:
k = tuple(map(operator.add, d, e))
if not (0 <= k[0] < len(matrix)) or not (0 <= k[1] < len(matrix[0])) \
or (matrix[k[0]][k[1]] <= matrix[e[0]][e[1]] + 1):
continue
else:
matrix[k[0]][k[1]] = matrix[e[0]][e[1]] + 1
deque.append(k)
return matrix
如果是在LeetCode网站上提交的话，可以发现时间排名是属于垫底的那种。
好吧，那么有没有更好的解法？好在LeetCode里面有Discussion即大神们的讨论区。
首先来看DP解法：
# Time: O(m * n)
# Space: O(m * n)
# dp solution
class Solution2(object):
def updateMatrix(self, matrix):
"""
:type matrix: List[List[int]]
:rtype: List[List[int]]
"""
dp = [[float("inf")]*len(matrix[0]) for _ in xrange(len(matrix))]
for i in xrange(len(matrix)):
for j in xrange(len(matrix[i])):
if matrix[i][j] == 0:
dp[i][j] = 0
else:
if i > 0:
dp[i][j] = min(dp[i][j], dp[i-1][j]+1)
if j > 0:
dp[i][j] = min(dp[i][j], dp[i][j-1]+1)
for i in reversed(xrange(len(matrix))):
for j in reversed(xrange(len(matrix[i]))):
if matrix[i][j] == 0:
dp[i][j] = 0
else:
if i < len(matrix)-1:
dp[i][j] = min(dp[i][j], dp[i+1][j]+1)
if j < len(matrix[i])-1:
dp[i][j] = min(dp[i][j], dp[i][j+1]+1)
return dp
说是DP，其实本质还是距离+1那一套，只不过分成了两遍扫描，第一遍看左边和上边，第二遍看右边和下边。这里需要注意一下扫描方向，第一遍是横向正向扫描，确保左边和上边的已经被扫过，也就是说有0的话也会正确计算，至于0前面的就在下一次扫描里面算。第二遍类似。
这样每个元素都检查了四个方向，虽然分成两部分，但是这两部分互不干涉。
严格的数学证明估计是没有的，不过无论从直觉还是结果来看，这个算法都是正确的。
再往前一步，既然可以分成两部分，那分成四部分，分别的四个方向呢？答案是也可以。
def updateMatrix(self, matrix):
answer = [[10000 * x for x in row] for row in matrix]
for _ in range(4):
for row in answer:
for j in range(1, len(row)):
row[j] = min(row[j], row[j-1] + 1)
answer = map(list, zip(*answer[::-1]))
return answer
这个答案更加短小精悍。
answer = [[10000 * x for x in row] for row in matrix]这句代码是将矩阵进行初始化，不过因为float('inf')*0=nan即Not a number，这里选择10000来当乘数，因为根据题意距离总是会小于10000的。
对于每一行从左向右，计算左边一格+1。方向的原理和DP解法类似，左边的是已经遍历过的所以拿过来计算。
然后把矩阵转置。重复4次。
这样虽然每次计算都是向右，但是矩阵在转，转了一圈就相当于计算了四个方向。
总结
很有代表性的BFS题，值得认真推敲。
