[LeetCode 542] 01 Matrix

最新推荐文章于 2020-07-28 10:38:59 发布

ExcitedZhang

最新推荐文章于 2020-07-28 10:38:59 发布

阅读量209

点赞数

CC 4.0 BY-SA版权

分类专栏： LeetCode 文章标签： LeetCode 广搜

本文链接：https://blog.youkuaiyun.com/ExcitedZhang/article/details/90108593

LeetCode 专栏收录该内容

118 篇文章

订阅专栏

本文介绍了一种高效解决01矩阵问题的方法，通过广度优先搜索（BFS）从所有值为0的元素开始，计算矩阵中每个元素到最近0的距离。这种方法避免了深度优先搜索（DFS）可能带来的超时问题，确保了算法的运行效率。

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为起点，搜索附近的点，如果搜索的点的distance大于当前搜索的路径，则压入队列。

Code

class Solution {
public:
    vector<vector<int>> updateMatrix(vector<vector<int>>& matrix) {
        
        int rows = matrix.size();
        if (rows == 0)
            return vector<vector<int>>();
        int cols = matrix[0].size();
        vector<vector<int>> res(rows+2, vector<int>(cols+2, INT_MAX));
        queue<pair<int, int>> q;
        for (int i = 0; i < rows; i ++)
        {
            for (int j = 0; j < cols; j ++)
            {
                if (matrix[i][j] == 0)
                {
                    res[i+1][j+1] = 0;
                    q.push(make_pair(i+1, j+1));
                }
            }
        }
        
        while (!q.empty())
        {
            int x = q.front().first;
            int y = q.front().second;
            if (x < 1 || x > rows || y < 1 || y > cols)
            {
                q.pop();
                continue;
            }

            q.pop();
            if (res[x-1][y] > res[x][y] + 1)
            {
                q.push(make_pair(x-1, y));
                res[x-1][y] = res[x][y]+1;
            }
            if (res[x+1][y] > res[x][y] + 1)
            {
                q.push(make_pair(x+1, y));
                res[x+1][y] = res[x][y]+1;
            }
            if (res[x][y-1] > res[x][y] + 1)
            {
                q.push(make_pair(x, y-1));
                res[x][y-1] = res[x][y]+1;
            }
            if (res[x][y+1] > res[x][y] + 1)
            {
                q.push(make_pair(x, y+1));
                res[x][y+1] = res[x][y]+1;
            }
        }
        
        res.pop_back();
        res.erase(res.begin());
        for (int i = 0; i < rows; i ++)
        {
            res[i].pop_back();
            res[i].erase(res[i].begin());
        }
        return res;
    }
};

运行效率

Runtime: 192 ms, faster than 83.61% of C++ online submissions for 01 Matrix.

Memory Usage: 25.1 MB, less than 39.33% of C++ online submissions for01 Matrix.