LeetCode 1162. As Far from Land as Possible

Author: raul-sauco

README.md

@@ -341,6 +341,7 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 | [1137. N-th Tribonacci Number][lc1137]                                         | 🟢 Easy    | [![python](res/py.png)][lc1137py] [![rust](res/rs.png)][lc1137rs]                            |
 | [1143. Longest Common Subsequence][lc1143]                                     | 🟠 Medium  | [![python](res/py.png)][lc1143py]                                                            |
 | [1155. Number of Dice Rolls With Target Sum][lc1155]                           | 🟠 Medium  | [![python](res/py.png)][lc1155py]                                                            |
+| [1162. As Far from Land as Possible][lc1162]                                   | 🟠 Medium  | [![python](res/py.png)][lc1162py] [![rust](res/rs.png)][lc1162rs]                            |
 | [1207. Unique Number of Occurrences][lc1207]                                   | 🟢 Easy    | [![python](res/py.png)][lc1207py]                                                            |
 | [1220. Count Vowels Permutation][lc1220]                                       | 🔴 Hard    | [![python](res/py.png)][lc1220py]                                                            |
 | [1235. Maximum Profit in Job Scheduling][lc1235]                               | 🔴 Hard    | [![python](res/py.png)][lc1235py]                                                            |
@@ -1084,7 +1085,10 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 [lc1143]: https://leetcode.com/problems/longest-common-subsequence/
 [lc1143py]: leetcode/longest-common-subsequence.py
 [lc1155]: https://leetcode.com/problems/number-of-dice-rolls-with-target-sum/
-[lc1155py]: ../number-of-dice-rolls-with-target-sum.py
+[lc1155py]: leetcode/number-of-dice-rolls-with-target-sum.py
+[lc1162]: https://leetcode.com/problems/as-far-from-land-as-possible/
+[lc1162py]: leetcode/as-far-from-land-as-possible.py
+[lc1162rs]: leetcode/as-far-from-land-as-possible.rs
 [lc1207]: https://leetcode.com/problems/unique-number-of-occurrences/
 [lc1207py]: leetcode/unique-number-of-occurrences.py
 [lc1220]: https://leetcode.com/problems/count-vowels-permutation/

leetcode/as-far-from-land-as-possible.py

@@ -0,0 +1,91 @@
+# 1162. As Far from Land as Possible
+# 🟠 Medium
+#
+# https://leetcode.com/problems/as-far-from-land-as-possible/
+#
+# Tags: Array - Dynamic Programming - Breadth-First Search - Matrix
+
+import timeit
+from typing import List
+
+
+# Use BFS and a matrix with the current shortest distance between any
+# cell and land to compute the shortest distance between any cell and
+# land, we will only revisit cells when the new distance to land is
+# less than the shortest previous distance found, which may, in turn,
+# influence its neighbors by providing a shorter path to land.
+#
+# Time complexity: O(m+n) - We can travel a maximum of n levels, on each
+# level, we will only visit cells to which we have not previously found
+# a shorter route, in total we will visit m*n cells during the BFS.
+# Space complexity: O(m+n) - The distance matrix has the same size as
+# the input matrix, m rows and n columns.
+#
+# Runtime 548 ms Beats 82.97%
+# Memory 14.6 MB Beats 64.75%
+class Solution:
+    def maxDistance(self, grid: List[List[int]]) -> int:
+        m, n = len(grid), len(grid[0])
+        # A matrix of distances to land.
+        dist = [[float("inf")] * n for _ in range(m)]
+        # Use a stack to do a per-level BFS.
+        current_level, level = [], 0
+        # Add land cells to the first level.
+        for i in range(m):
+            for j in range(n):
+                if grid[i][j] == 1:
+                    current_level.append((i, j))
+                    # Mark this cell as 0 units away from land.
+                    dist[i][j] = 0
+        # If the grid has no water or land, return -1.
+        if not len(current_level) or len(current_level) == (m * n):
+            return -1
+        # Keep exploring as long as the current level has any elements.
+        while current_level:
+            next_level = []
+            level += 1
+            # Process one level at a time.
+            for _ in range(len(current_level)):
+                r, c = current_level.pop()
+                for nr, nc in ((r + 1, c), (r - 1, c), (r, c + 1), (r, c - 1)):
+                    # The cell needs to be within boundaries, it should
+                    # not be land and we should not have a shorter path
+                    # to land already.
+                    if 0 <= nr < m and 0 <= nc < n and level < dist[nr][nc]:
+                        dist[nr][nc] = level
+                        next_level.append((nr, nc))
+            current_level = next_level
+        return level - 1
+
+
+def test():
+    executors = [Solution]
+    tests = [
+        [[[1]], -1],
+        [[[0]], -1],
+        [[[0, 0], [0, 0], [0, 0]], -1],
+        [[[1, 1], [1, 1], [1, 1]], -1],
+        [[[1, 0], [0, 0], [1, 0]], 2],
+        [[[1, 0, 1], [0, 0, 0], [1, 0, 1]], 2],
+        [[[1, 0, 0], [0, 0, 0], [0, 0, 0]], 4],
+        [[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], -1],
+    ]
+    for executor in executors:
+        start = timeit.default_timer()
+        for _ in range(1):
+            for col, t in enumerate(tests):
+                sol = executor()
+                result = sol.maxDistance(t[0])
+                exp = t[1]
+                assert result == exp, (
+                    f"\033[93m» {result} <> {exp}\033[91m for"
+                    + f" test {col} using \033[1m{executor.__name__}"
+                )
+        stop = timeit.default_timer()
+        used = str(round(stop - start, 5))
+        cols = "{0:20}{1:10}{2:10}"
+        res = cols.format(executor.__name__, used, "seconds")
+        print(f"\033[92m» {res}\033[0m")
+
+
+test()

leetcode/as-far-from-land-as-possible.rs

@@ -0,0 +1,76 @@
+// 1162. As Far from Land as Possible
+// 🟠 Medium
+//
+// https://leetcode.com/problems/as-far-from-land-as-possible/
+//
+// Tags: Array - Dynamic Programming - Breadth-First Search - Matrix
+
+struct Solution;
+impl Solution {
+    // Use BFS and a matrix with the current shortest distance between any
+    // cell and land to compute the shortest distance between any cell and
+    // land, we will only revisit cells when the new distance to land is
+    // less than the shortest previous distance found, which may, in turn,
+    // influence its neighbors by providing a shorter path to land.
+    //
+    // Time complexity: O(m+n) - We can travel a maximum of n levels, on each
+    // level, we will only visit cells to which we have not previously found
+    // a shorter route, in total we will visit m*n cells during the BFS.
+    // Space complexity: O(m+n) - The distance matrix has the same size as
+    // the input matrix, m rows and n columns.
+    //
+    // Runtime 12 ms Beats 66.67%
+    // Memory 2.3 MB Beats 93.33%
+    pub fn max_distance(grid: Vec<Vec<i32>>) -> i32 {
+        let m = grid.len();
+        let n = grid[0].len();
+        let mut dist: Vec<Vec<usize>> = vec![vec![1000; n]; m];
+        let mut current_level: Vec<(i16, i16)> = vec![];
+        let mut level: usize = 0;
+        for i in 0..m {
+            for j in 0..n {
+                if grid[i][j] == 1 {
+                    current_level.push((i as i16, j as i16));
+                    dist[i][j] = 0;
+                }
+            }
+        }
+        if current_level.len() == 0 || current_level.len() == (m * n) {
+            return -1;
+        }
+        while current_level.len() > 0 {
+            let mut next_level = Vec::<(i16, i16)>::new();
+            level += 1;
+            // Process the current entire level.
+            for _ in 0..current_level.len() {
+                let (r, c) = current_level.pop().unwrap();
+                for (nr, nc) in [(r + 1, c), (r - 1, c), (r, c + 1), (r, c - 1)] {
+                    if 0 <= nr
+                        && nr < m as i16
+                        && 0 <= nc
+                        && nc < n as i16
+                        && level < dist[nr as usize][nc as usize]
+                    {
+                        dist[nr as usize][nc as usize] = level;
+                        next_level.push((nr, nc));
+                    }
+                }
+            }
+            current_level = next_level;
+        }
+        (level - 1) as i32
+    }
+}
+
+// Tests.
+fn main() {
+    assert_eq!(
+        Solution::max_distance(vec![vec![1, 0, 1], vec![0, 0, 0], vec![1, 0, 1]]),
+        2
+    );
+    assert_eq!(
+        Solution::max_distance(vec![vec![1, 0, 0], vec![0, 0, 0], vec![0, 0, 0]]),
+        4
+    );
+    println!("All tests passed!")
+}