2258. Escape the Spreading Fire: RETRY

Author: tan-wei

src/solution/mod.rs

@@ -1708,3 +1708,4 @@ mod s2251_number_of_flowers_in_full_bloom;
 mod s2255_count_prefixes_of_a_given_string;
 mod s2256_minimum_average_difference;
 mod s2257_count_unguarded_cells_in_the_grid;
+mod s2258_escape_the_spreading_fire;

src/solution/s2258_escape_the_spreading_fire.rs

@@ -0,0 +1,103 @@
+/**
+ * [2258] Escape the Spreading Fire
+ *
+ * You are given a 0-indexed 2D integer array grid of size m x n which represents a field. Each cell has one of three values:
+ *
+ * 	0 represents grass,
+ * 	1 represents fire,
+ * 	2 represents a wall that you and fire cannot pass through.
+ *
+ * You are situated in the top-left cell, (0, 0), and you want to travel to the safehouse at the bottom-right cell, (m - 1, n - 1). Every minute, you may move to an adjacent grass cell. After your move, every fire cell will spread to all adjacent cells that are not walls.
+ * Return the maximum number of minutes that you can stay in your initial position before moving while still safely reaching the safehouse. If this is impossible, return -1. If you can always reach the safehouse regardless of the minutes stayed, return 10^9.
+ * Note that even if the fire spreads to the safehouse immediately after you have reached it, it will be counted as safely reaching the safehouse.
+ * A cell is adjacent to another cell if the former is directly north, east, south, or west of the latter (i.e., their sides are touching).
+ *  
+ * Example 1:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2022/03/10/ex1new.jpg" style="width: 650px; height: 404px;" />
+ * Input: grid = [[0,2,0,0,0,0,0],[0,0,0,2,2,1,0],[0,2,0,0,1,2,0],[0,0,2,2,2,0,2],[0,0,0,0,0,0,0]]
+ * Output: 3
+ * Explanation: The figure above shows the scenario where you stay in the initial position for 3 minutes.
+ * You will still be able to safely reach the safehouse.
+ * Staying for more than 3 minutes will not allow you to safely reach the safehouse.
+ * Example 2:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2022/03/10/ex2new2.jpg" style="width: 515px; height: 150px;" />
+ * Input: grid = [[0,0,0,0],[0,1,2,0],[0,2,0,0]]
+ * Output: -1
+ * Explanation: The figure above shows the scenario where you immediately move towards the safehouse.
+ * Fire will spread to any cell you move towards and it is impossible to safely reach the safehouse.
+ * Thus, -1 is returned.
+ *
+ * Example 3:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2022/03/10/ex3new.jpg" style="width: 174px; height: 150px;" />
+ * Input: grid = [[0,0,0],[2,2,0],[1,2,0]]
+ * Output: 1000000000
+ * Explanation: The figure above shows the initial grid.
+ * Notice that the fire is contained by walls and you will always be able to safely reach the safehouse.
+ * Thus, 10^9 is returned.
+ *
+ *  
+ * Constraints:
+ *
+ * 	m == grid.length
+ * 	n == grid[i].length
+ * 	2 <= m, n <= 300
+ * 	4 <= m * n <= 2 * 10^4
+ * 	grid[i][j] is either 0, 1, or 2.
+ * 	grid[0][0] == grid[m - 1][n - 1] == 0
+ *
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/escape-the-spreading-fire/
+// discuss: https://leetcode.com/problems/escape-the-spreading-fire/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+impl Solution {
+    pub fn maximum_minutes(grid: Vec<Vec<i32>>) -> i32 {
+        0
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    #[ignore]
+    fn test_2258_example_1() {
+        let grid = vec![
+            vec![0, 2, 0, 0, 0, 0, 0],
+            vec![0, 0, 0, 2, 2, 1, 0],
+            vec![0, 2, 0, 0, 1, 2, 0],
+            vec![0, 0, 2, 2, 2, 0, 2],
+            vec![0, 0, 0, 0, 0, 0, 0],
+        ];
+
+        let result = 3;
+
+        assert_eq!(Solution::maximum_minutes(grid), result);
+    }
+
+    #[test]
+    #[ignore]
+    fn test_2258_example_2() {
+        let grid = vec![vec![0, 0, 0, 0], vec![0, 1, 2, 0], vec![0, 2, 0, 0]];
+
+        let result = -1;
+
+        assert_eq!(Solution::maximum_minutes(grid), result);
+    }
+
+    #[test]
+    #[ignore]
+    fn test_2258_example_3() {
+        let grid = vec![vec![0, 0, 0], vec![2, 2, 0], vec![1, 2, 0]];
+
+        let result = 1000000000;
+
+        assert_eq!(Solution::maximum_minutes(grid), result);
+    }
+}