feat: add solutions to lc problem: No.0994

No.0994.Rotting Oranges

Author: yanglbme

solution/0900-0999/0994.Rotting Oranges/README.md

@@ -65,31 +65,27 @@
 ```python
 class Solution:
     def orangesRotting(self, grid: List[List[int]]) -> int:
-        R, C = len(grid), len(grid[0])
-
-        # queue - all starting cells with rotting oranges
-        queue = collections.deque()
-        for r, row in enumerate(grid):
-            for c, val in enumerate(row):
-                if val == 2:
-                    queue.append((r, c, 0))
-
-        def neighbors(r, c) -> (int, int):
-            for nr, nc in ((r - 1, c), (r, c - 1), (r + 1, c), (r, c + 1)):
-                if 0 <= nr < R and 0 <= nc < C:
-                    yield nr, nc
-
-        d = 0
-        while queue:
-            r, c, d = queue.popleft()
-            for nr, nc in neighbors(r, c):
-                if grid[nr][nc] == 1:
-                    grid[nr][nc] = 2
-                    queue.append((nr, nc, d + 1))
-
-        if any(1 in row for row in grid):
-            return -1
-        return d
+        m, n = len(grid), len(grid[0])
+        q = deque()
+        cnt = 0
+        for i in range(m):
+            for j in range(n):
+                if grid[i][j] == 2:
+                    q.append((i, j))
+                elif grid[i][j] == 1:
+                    cnt += 1
+        ans = 0
+        while q and cnt:
+            ans += 1
+            for _ in range(len(q), 0, -1):
+                i, j = q.popleft()
+                for a, b in [[0, 1], [0, -1], [1, 0], [-1, 0]]:
+                    x, y = i + a, j + b
+                    if 0 <= x < m and 0 <= y < n and grid[x][y] == 1:
+                        cnt -= 1
+                        grid[x][y] = 2
+                        q.append((x, y))
+        return ans if cnt == 0 else -1
 ```
 
 ### **Java**
@@ -98,46 +94,37 @@ class Solution:
 
 ```java
 class Solution {
-    int[] dr = new int[] { -1, 0, 1, 0 };
-    int[] dc = new int[] { 0, -1, 0, 1 };
-
     public int orangesRotting(int[][] grid) {
-        int R = grid.length, C = grid[0].length;
-        Queue<Integer> queue = new ArrayDeque<Integer>();
-        Map<Integer, Integer> depth = new HashMap<Integer, Integer>();
-        for (int r = 0; r < R; ++r) {
-            for (int c = 0; c < C; ++c) {
-                if (grid[r][c] == 2) {
-                    int code = r * C + c;
-                    queue.add(code);
-                    depth.put(code, 0);
+        int m = grid.length, n = grid[0].length;
+        int cnt = 0;
+        Deque<int[]> q = new LinkedList<>();
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (grid[i][j] == 2) {
+                    q.offer(new int[]{i, j});
+                } else if (grid[i][j] == 1) {
+                    ++cnt;
                 }
             }
         }
         int ans = 0;
-        while (!queue.isEmpty()) {
-            int code = queue.remove();
-            int r = code / C, c = code % C;
-            for (int k = 0; k < 4; ++k) {
-                int nr = r + dr[k];
-                int nc = c + dc[k];
-                if (0 <= nr && nr < R && 0 <= nc && nc < C && grid[nr][nc] == 1) {
-                    grid[nr][nc] = 2;
-                    int ncode = nr * C + nc;
-                    queue.add(ncode);
-                    depth.put(ncode, depth.get(code) + 1);
-                    ans = depth.get(ncode);
-                }
-            }
-        }
-        for (int[] row : grid) {
-            for (int v : row) {
-                if (v == 1) {
-                    return -1;
+        int[] dirs = {1, 0, -1, 0, 1};
+        while (!q.isEmpty() && cnt > 0) {
+            ++ans;
+            for (int i = q.size(); i > 0; --i) {
+                int[] p = q.poll();
+                for (int j = 0; j < 4; ++j) {
+                    int x = p[0] + dirs[j];
+                    int y = p[1] + dirs[j + 1];
+                    if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1) {
+                        grid[x][y] = 2;
+                        --cnt;
+                        q.offer(new int[]{x, y});
+                    }
                 }
             }
         }
-        return ans;
+        return cnt > 0 ? -1 : ans;
     }
 }
 ```
@@ -148,56 +135,87 @@ class Solution {
 
 ```cpp
 class Solution {
-    int cnt;
-    int dis[10][10];
-    int dir_x[4] = {0, 1, 0, -1};
-    int dir_y[4] = {1, 0, -1, 0};
-
 public:
-    int orangesRotting(vector<vector<int>> &grid) {
-        queue<pair<int, int>> Q;
-        memset(dis, -1, sizeof(dis));
-        cnt = 0;
-        int n = (int)grid.size(), m = (int)grid[0].size(), ans = 0;
-        for (int i = 0; i < n; ++i)
+    int orangesRotting(vector<vector<int>>& grid) {
+        int m = grid.size(), n = grid[0].size();
+        int cnt = 0;
+        typedef pair<int, int> pii;
+        queue<pii> q;
+        for (int i = 0; i < m; ++i)
         {
-            for (int j = 0; j < m; ++j)
+            for (int j = 0; j < n; ++j)
             {
-                if (grid[i][j] == 2)
-                {
-                    Q.push(make_pair(i, j));
-                    dis[i][j] = 0;
-                }
-                else if (grid[i][j] == 1)
-                    cnt += 1;
+                if (grid[i][j] == 2) q.emplace(i, j);
+                else if (grid[i][j] == 1) ++cnt;
             }
         }
-        while (!Q.empty())
+        int ans = 0;
+        vector<int> dirs = {-1, 0, 1, 0, -1};
+        while (!q.empty() && cnt > 0)
         {
-            pair<int, int> x = Q.front();
-            Q.pop();
-            for (int i = 0; i < 4; ++i)
+            ++ans;
+            for (int i = q.size(); i > 0; --i)
             {
-                int tx = x.first + dir_x[i];
-                int ty = x.second + dir_y[i];
-                if (tx < 0 || tx >= n || ty < 0 || ty >= m || ~dis[tx][ty] || !grid[tx][ty])
-                    continue;
-                dis[tx][ty] = dis[x.first][x.second] + 1;
-                Q.push(make_pair(tx, ty));
-                if (grid[tx][ty] == 1)
+                auto p = q.front();
+                q.pop();
+                for (int j = 0; j < 4; ++j)
                 {
-                    cnt -= 1;
-                    ans = dis[tx][ty];
-                    if (!cnt)
-                        break;
+                    int x = p.first + dirs[j];
+                    int y = p.second + dirs[j + 1];
+                    if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1)
+                    {
+                        --cnt;
+                        grid[x][y] = 2;
+                        q.emplace(x, y);
+                    }
                 }
             }
         }
-        return cnt ? -1 : ans;
+        return cnt > 0 ? -1 : ans;
     }
 };
 ```
 
+### **Go**
+
+```go
+func orangesRotting(grid [][]int) int {
+	m, n := len(grid), len(grid[0])
+	cnt := 0
+	var q [][]int
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			if grid[i][j] == 2 {
+				q = append(q, []int{i, j})
+			} else if grid[i][j] == 1 {
+				cnt++
+			}
+		}
+	}
+	ans := 0
+	dirs := []int{-1, 0, 1, 0, -1}
+	for len(q) > 0 && cnt > 0 {
+		ans++
+		for i := len(q); i > 0; i-- {
+			p := q[0]
+			q = q[1:]
+			for j := 0; j < 4; j++ {
+				x, y := p[0]+dirs[j], p[1]+dirs[j+1]
+				if x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1 {
+					cnt--
+					grid[x][y] = 2
+					q = append(q, []int{x, y})
+				}
+			}
+		}
+	}
+	if cnt > 0 {
+		return -1
+	}
+	return ans
+}
+```
+
 ### **...**
 
 ```