LeetCode学习-第十七天

第十七天

我使用的C++，错误的地方请见谅，文章初衷仅用来督促本人学习，如果恰巧能够给你带来帮助，我会十分开心。

一、542. 01 矩阵

给定一个由 0 和 1 组成的矩阵 mat ，请输出一个大小相同的矩阵，其中每一个格子是 mat 中对应位置元素到最近的 0 的距离。

两个相邻元素间的距离为 1 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/01-matrix
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

这个超级源点理论能理解，但是这个超级源点是怎么实现的？

class Solution {
public:
    static constexpr int dirs[4][2] = {{-1, 0},{1, 0},{0, -1},{0, 1}};
    vector<vector<int>> updateMatrix(vector<vector<int>>& mat) {
        //对所有格子遍历，对每一个元素寻找它上下左右最近的0的位置，没有就向外扩散，扩散一次count++
        int m = mat.size(), n = mat[0].size();
        vector<vector<int>> dist(m, vector<int>(n));//二维数组记录距离
        vector<vector<int>> seen(m, vector<int>(n));//二维数组记录是否遍历过
        queue<pair<int, int>> que;//队列用来储存0
        for (int i = 0; i < m; ++i){
            for (int j = 0; j < n; ++j){
                if (mat[i][j] == 0){//将所有0入队，剩下的就是1，同时，先将所有0入队就意味着构建了一个超级源点
                    que.emplace(i, j);
                    seen[i][j] = 1;
                }
            }

        }
        while (!que.empty()){
            auto [i, j] = que.front();//这句没用过
            que.pop();
            for (int k = 0; k < 4; ++k){
                int ni = i + dirs[k][0];
                int nj = j + dirs[k][1];
                if (ni >= 0 && ni < m && nj >= 0 && nj < n && !seen[ni][nj]){
                    dist[ni][nj] = dist[i][j] + 1;//没被遍历过的，且为1的，且合法的地方加一
                    que.emplace (ni, nj);
                    seen[ni][nj] = 1;
                }
            }

        }
        return dist;
    }
};

二、994. 腐烂的橘子

在给定的网格中，每个单元格可以有以下三个值之一：

值 0 代表空单元格；
值 1 代表新鲜橘子；
值 2 代表腐烂的橘子。
每分钟，任何与腐烂的橘子（在 4 个正方向上）相邻的新鲜橘子都会腐烂。

返回直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/rotting-oranges
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
public:
    static constexpr int dirs[4][2] = {{0, 1},{0, -1},{1, 0},{-1, 0}};
    int orangesRotting(vector<vector<int>>& grid) {
        //广度优先进行遍历，最后遍历一下，如果还有没被遍历到的，则输出-1
        queue<pair<int, int>> que;
       
        int m = grid.size(), n = grid[0].size(), cnt = 0, ans = 0;
         vector<vector<int>> dist(m, vector<int>(n));
        for (int i = 0; i < m; ++i){
            for (int j = 0; j < n; ++j){
                if (grid[i][j] == 2){//a将所有2值压入，形成超级源点
                    que.emplace(i, j);
                    //dist[i][j] = 0;
                }
                else if (grid[i][j] == 1){//将所有1值计数
                    ++cnt;
                }
            }
        }
        while (!que.empty()){
            auto [x, y] = que.front();
            que.pop();
            
            
            for (int k = 0; k < 4; ++k){
                int nx = x + dirs[k][0];
                int ny = y + dirs[k][1];
                if (nx >= 0 && nx < m && ny >= 0 && ny < n && grid[nx][ny] == 1 && dist[nx][ny] == 0){
                    dist[nx][ny] = dist[x][y] + 1;
                    que.emplace (nx, ny);
                    --cnt;//每有一个1值
                    //grid[x][y] = 2;
                    ans = dist[nx][ny];
                    if (!cnt) break;
                    
                }
            }
            

        }
        if (cnt != 0){
            return -1;
        }
        else {
            return ans;
        }
        
    }
};