add a solution for 994

Author: fishercoder1534

src/main/java/com/fishercoder/solutions/_994.java

@@ -1,7 +1,9 @@
 package com.fishercoder.solutions;
 
+import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.Queue;
+import java.util.Set;
 
 public class _994 {
     public static class Solution1 {
@@ -46,4 +48,49 @@ public int orangesRotting(int[][] grid) {
             return times;
         }
     }
+
+    public static class Solution2 {
+        /**
+         * My completely original solution on 10/11/2021.
+         */
+        public int orangesRotting(int[][] grid) {
+            int m = grid.length;
+            int n = grid[0].length;
+            Queue<int[]> queue = new LinkedList<>();
+            Set<Integer> fresh = new HashSet<>();
+            for (int i = 0; i < m; i++) {
+                for (int j = 0; j < n; j++) {
+                    if (grid[i][j] == 1) {
+                        fresh.add(i * n + j);
+                    } else if (grid[i][j] == 2) {
+                        queue.offer(new int[]{i, j});
+                    }
+                }
+            }
+            int min = 0;
+            int[] directions = new int[]{0, 1, 0, -1, 0};
+            while (!queue.isEmpty() && !fresh.isEmpty()) {
+                int size = queue.size();
+                if (size > 0) {
+                    min++;
+                }
+                for (int i = 0; i < size; i++) {
+                    int[] curr = queue.poll();
+                    for (int k = 0; k < directions.length - 1; k++) {
+                        int nextX = curr[0] + directions[k];
+                        int nextY = curr[1] + directions[k + 1];
+                        if (nextX >= 0 && nextX < m && nextY >= 0 && nextY < n && grid[nextX][nextY] == 1) {
+                            fresh.remove(nextX * n + nextY);
+                            if (fresh.isEmpty()) {
+                                return min;
+                            }
+                            grid[nextX][nextY] = 2;
+                            queue.offer(new int[]{nextX, nextY});
+                        }
+                    }
+                }
+            }
+            return fresh.isEmpty() ? min : -1;
+        }
+    }
 }

src/test/java/com/fishercoder/_994Test.java

@@ -1,5 +1,6 @@
 package com.fishercoder;
 
+import com.fishercoder.common.utils.CommonUtils;
 import com.fishercoder.solutions._994;
 import org.junit.BeforeClass;
 import org.junit.Test;
@@ -8,11 +9,13 @@
 
 public class _994Test {
     private static _994.Solution1 solution1;
+    private static _994.Solution2 solution2;
     private static int[][] grid;
 
     @BeforeClass
     public static void setUp() {
         solution1 = new _994.Solution1();
+        solution2 = new _994.Solution2();
     }
 
     @Test
@@ -42,4 +45,27 @@ public void test3() {
         };
         assertEquals(0, solution1.orangesRotting(grid));
     }
+
+    @Test
+    public void test4() {
+        grid = new int[][]{
+                {2, 1, 1},
+                {1, 1, 0},
+                {0, 1, 1}
+        };
+        assertEquals(4, solution2.orangesRotting(grid));
+    }
+
+    @Test
+    public void test5() {
+        grid = CommonUtils.convertLeetCodeIrregularLengths2DArrayInputIntoJavaArray("[2,0,0,1,0,1],[2,0,0,1,2,0]");
+        assertEquals(-1, solution2.orangesRotting(grid));
+    }
+
+    @Test
+    public void test6() {
+        grid = CommonUtils.convertLeetCodeIrregularLengths2DArrayInputIntoJavaArray("[2],[1]");
+        assertEquals(1, solution2.orangesRotting(grid));
+    }
+
 }