力扣刷题-542.01矩阵

给定一个由 0 和 1 组成的矩阵，找出每个元素到最近的 0 的距离。
两个相邻元素间的距离为 1 。
注意:
  给定矩阵的元素个数不超过 10000。
  给定矩阵中至少有一个元素是 0。
 矩阵中的元素只在四个方向上相邻: 上、下、左、右。

题目分析

1. 求最短距离
     求最短距离，一般采用广度优先搜索的算法，从源点出发，最先遍历到的目标点，一定是距离源点最短的点，遍历增加一层则距离加1。

2. 暴力解法
     本题要求每个元素到0的距离，若本身为0则距离为0，实际找的是所有1到0的距离。可以遍历矩阵的每个点，若为1则执行一遍广度优先搜索，从而得点没个点到0的距离。但暴力解法会造成很高的时间复杂度，以及会有大量的重复计算。

3. 增加超级源点
     求1到0的距离，和0到1的距离是一样的，每个0找到距离最短的1，同时也是这个1距离最短的0。因此可以把所有的0看作是一个整体，一层一层的向外扩散，每一层扩散到的1即为这个1到0的最短距离。
     可以理解为有一个超级源点，超级源点和所有的0相连，从超级源点出发，每层找到的1的距离减1即为1到0的距离。

广度优先搜索

1. BFS
     广度优先搜索的本质是对层按顺序遍历，把每一层的所有点访问完后再转到下一层。使用队列（queue）来记录将要访问的点，访问完每个点就出队，然后把它的邻近点入队，同时要记录哪些点被访问过以避免重复访问。
   
2. 模版

epth = 0 # 记录遍历到第几层，当前在第几层则和源点的距离为几
while queue 非空:
    depth++
    n = queue 中的元素个数
    循环 n 次:
        node = queue.pop()
        for node 的所有相邻结点 m:
            if m 未访问过:
                queue.push(m)

代码示例

class Solution {
public:
    vector<vector<int>> updateMatrix(vector<vector<int>>& matrix) {
        
        vector<vector<int>> resault = vector(matrix.size(),vector<int>(matrix[0].size()));
        
        vector<vector<int>> vis = vector(matrix.size(),vector<int>(matrix[0].size(),0));//标记是否访问
        queue<vector<int>> my_queue;//建立队列
        //所有0入队
        for(int x = 0;x < matrix.size();x++)//遍历行
        {
            for(int y = 0;y < matrix[0].size();y++)//遍历列
            {
                if( matrix[x][y] == 0) 
                {
                    my_queue.push({x,y});
                    vis[x][y] = 1;
                }
            }
        }
        int res = -1;
        while( !my_queue.empty())
        {
            res++;//遍历了多少层//第0层为0
            int queue_size = my_queue.size();
            for(int i = 0; i < queue_size ;i++)
            {
                vector<int> cur = my_queue.front();my_queue.pop();
                int cur_x = cur[0];
                int cur_y = cur[1];
                resault[cur_x][cur_y] = res;
               
                //上
                if( cur_x-1 >=0 &&  vis[cur_x-1][cur_y] == 0)
                {
                    my_queue.push({cur_x-1,cur_y});
                    vis[cur_x-1][cur_y] = 1;//该点走过了
                } 
                //下
                if( cur_x +1 <= matrix.size()-1 &&  vis[cur_x+1][cur_y] == 0) 
                {
                    my_queue.push({cur_x+1,cur_y});
                    vis[cur_x+1][cur_y] = 1;//该点走过了
                }
                //左
                if( cur_y-1 >=0 && vis[cur_x][cur_y-1] == 0) 
                {
                    my_queue.push({cur_x,cur_y-1});
                    vis[cur_x][cur_y-1] = 1;//该点走过了
                }
                //右
                if( cur_y +1 <= matrix[0].size()-1 && vis[cur_x][cur_y+1] == 0) 
                {
                    my_queue.push({cur_x,cur_y+1});
                    vis[cur_x][cur_y+1] = 1;//该点走过了
                }
            }
        }
        return resault;
    }
};