LeetCode994. 腐烂的橘子

/**
994. 腐烂的橘子
在给定的网格中，每个单元格可以有以下三个值之一：

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

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

 

示例 1：
输入：[[2,1,1],[1,1,0],[0,1,1]]
输出：4
示例 2：

输入：[[2,1,1],[0,1,1],[1,0,1]]
输出：-1
解释：左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个正向上。
示例 3：

输入：[[0,2]]
输出：0
解释：因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0 。
 

提示：

1 <= grid.length <= 10
1 <= grid[0].length <= 10
grid[i][j] 仅为 0、1 或 2

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/rotting-oranges
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
*/
typedef struct {
    int rowNum;
    int colNum;
} pos;
class Solution {
public:
    int orangesRotting(vector>& grid) {
        int row = grid.size();
        int col = grid[0].size();
        int orangeNum = 0;
        vector posVec;
        for(int i = 0; i < row; i++) {
            for(int j = 0; j < col; j++) {
                if(grid[i][j] != 0) {
                    orangeNum ++;
                    if(grid[i][j] == 2) {
                        posVec.push_back({i, j});
                    }
                }
            }
        }
        if(orangeNum == 0) {
            return 0;
        }
        if(posVec.size() == 0) {
            return -1;
        }
        int times = -1;
        int begin = -1;
        int end = 0;
        pos temp;
        while(begin != end) {
            times++;
            begin = end;
            end = posVec.size();
            for(int i = begin; i < end; i++) {
                temp = posVec[i];
                if (temp.rowNum - 1 >= 0 and grid[temp.rowNum - 1][temp.colNum] == 1) {
                    posVec.push_back({temp.rowNum - 1, temp.colNum});
                    grid[temp.rowNum - 1][temp.colNum] = 2;
                }
                if (temp.rowNum + 1 < row and grid[temp.rowNum + 1][temp.colNum] == 1) {
                    posVec.push_back({temp.rowNum + 1, temp.colNum});
                    grid[temp.rowNum + 1][temp.colNum] = 2;
                }
                if (temp.colNum - 1 >= 0 and grid[temp.rowNum][temp.colNum - 1] == 1) {
                    posVec.push_back({temp.rowNum, temp.colNum - 1});
                    grid[temp.rowNum][temp.colNum - 1] = 2;
                }
                if (temp.colNum + 1 < col and grid[temp.rowNum][temp.colNum + 1] == 1) {
                    posVec.push_back({temp.rowNum, temp.colNum + 1});
                    grid[temp.rowNum][temp.colNum + 1] = 2;
                }
            }
        }
        if (posVec.size() != orangeNum) {
            return -1;
        }
        else {
            return times - 1;
        }
    }
};

class Solution {
public:
    int orangesRotting(vector>& grid) {
        int row = grid.size();
        int column = grid[0].size();
        bool rot;
        int rotting = 2;
        do {
            rot = false;
            rotting++;
            for(int i = 0;i < row;i++) {
                for(int j = 0;j < column;j++) {
                    if(grid[i][j] >1 and grid[i][j] < rotting) {    //腐烂
                        if((i - 1) >= 0 and grid[i - 1][j] == 1) {
                            grid[i - 1][j] = rotting;
                            rot = true;
                        }
                        if((i + 1) < row and grid[i + 1][j] == 1) {
                            grid[i + 1][j] = rotting;
                            rot = true;
                        }
                        if((j - 1) >= 0 and grid[i][j - 1] == 1) {
                            grid[i][j - 1] = rotting;
                            rot = true;
                        }
                        if((j + 1) < column and grid[i][j + 1] == 1) {
                            grid[i][j + 1] = rotting;
                            rot = true;
                        }
                    }
                }
            }
        }while(rot);
        for(int i = 0;i < row;i++) {
            for(int j = 0;j < column;j++) {
                if(grid[i][j] == 1) {
                    return -1;
                }
            }
        }
        return rotting - 3;
    }
};