Leetcode: No.542 01 Matrix

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] + 1x肯定已经被遍历过了。

简而言之,由于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题,值得认真推敲。

推荐阅读更多精彩内容