feat(algorithms, graphs): iterative solution to max area of island

Author: BrianLusina

algorithms/graphs/maxareaofisland/README.md

@@ -7,17 +7,70 @@ The area of an island is the number of cells with a value 1 in the island.
 
 Return the maximum area of an island in grid. If there is no island, return 0.
 
+## Examples
+
 Example 1:
 
 ![max_area_island](maxarea-grid.jpg)
 
+```text
 Input: grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0]
 ,[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0]
 ,[0,0,0,0,0,0,0,1,1,0,0,0,0]]
 Output: 6
 Explanation: The answer is not 11, because the island must be connected 4-directionally.
+```
 
 Example 2:
-
+```text
 Input: grid = [[0,0,0,0,0,0,0,0]]
 Output: 0
+```
+
+## Solution
+
+1. [Depth-First Search (Recursive)](#depth-first-search-recursive)
+2. [Depth-First Search (Iterative)](#depth-first-search-iterative)
+
+### Depth-First Search (Recursive)
+
+We want to know the area of each connected shape in the grid, then take the maximum of these.
+
+If we are on a land square and explore every square connected to it 4-directionally (and recursively squares connected
+to those squares, and so on), then the total number of squares explored will be the area of that connected shape.
+
+To ensure we don't count squares in a shape more than once, let's use `visited` to keep track of squares we haven't
+visited before. It will also prevent us from counting the same shape more than once.
+
+#### Complexity Analysis
+
+##### Time Complexity
+
+`O(R*C)`, where R is the number of rows in the given grid, and C is the number of columns. We visit every square once.
+
+##### Space Complexity
+
+`O(R*C)`, the space used by seen to keep track of visited squares and the space used by the call stack during our
+recursion.
+
+### Depth-First Search (Iterative)
+
+We can try the same approach using a stack-based, (or "iterative") depth-first search.
+
+Here, `visited` will represent squares that have either been visited or are added to our list of squares to visit (`stack`).
+For every starting land square that hasn't been visited, we will explore 4-directionally around it, adding land squares
+that haven't been added to `visited` to our stack.
+
+On the side, we'll keep a count `shape` of the total number of squares seen during the exploration of this shape. We'll
+want the running max of these counts.
+
+#### Complexity Analysis
+
+##### Time Complexity
+
+`O(R*C)`, where R is the number of rows in the given grid, and C is the number of columns. We visit every square once.
+
+##### Space Complexity
+
+`O(R*C)`, the space used by seen to keep track of visited squares and the space used by stack
+

algorithms/graphs/maxareaofisland/__init__.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import List, Tuple, Set
 
 
 def max_area_of_island(grid: List[List[int]]) -> int:
@@ -7,11 +7,15 @@ def max_area_of_island(grid: List[List[int]]) -> int:
     connected 4-directionally (horizontal or vertical.) You may assume all 4
     edges of the grid are surrounded by water.
     this returns the maximum area of an island in the grid
+    Args:
+        grid(list): 2D array grid of 0s and 1s
+    Returns:
+        int: max area of island
     """
     num_rows, num_cols = len(grid), len(grid[0])
     max_area = 0
 
-    visited = set()
+    visited: Set[Tuple[int, int]] = set()
 
     def area(row: int, col: int) -> int:
         if not (
@@ -38,21 +42,41 @@ def area(row: int, col: int) -> int:
     return max_area
 
 
-def dfs(grid: List[List[int]], row: int, col: int) -> int:
-    visited = set()
-
-    if (
-        not (0 <= row < len(grid) and 0 <= col < len(grid[0]))
-        and (row, col) not in visited
-        and grid[row][col]
-    ):
-        return 0
-
-    visited.add((row, col))
-    return (
-        1
-        + dfs(grid, row + 1, col)
-        + dfs(grid, row - 1, col)
-        + dfs(grid, row, col + 1)
-        + dfs(grid, row, col - 1)
-    )
+def max_area_of_island_iterative(grid: List[List[int]]) -> int:
+    """
+    Given a non-empty 2D array grid of 0s and 1s, an island is a group of 1s
+    connected 4-directionally (horizontal or vertical.) You may assume all 4
+    edges of the grid are surrounded by water.
+    this returns the maximum area of an island in the grid
+    Args:
+        grid(list): 2D array grid of 0s and 1s
+    Returns:
+        int: max area of island
+    """
+    num_rows, num_cols = len(grid), len(grid[0])
+    max_area = 0
+
+    visited: Set[Tuple[int, int]] = set()
+
+    for row_idx, row in enumerate(grid):
+        for col_idx, val in enumerate(row):
+            if val and (row_idx, col_idx) not in visited:
+                shape = 0
+                stack = [(row_idx, col_idx)]
+                visited.add((row_idx, col_idx))
+
+                while stack:
+                    r, c = stack.pop()
+                    shape += 1
+                    for nr, nc in ((r - 1, c), (r + 1, c), (r, c - 1), (r, c + 1)):
+                        if (
+                            0 <= nr < num_rows
+                            and 0 <= nc < num_cols
+                            and grid[nr][nc]
+                            and (nr, nc) not in visited
+                        ):
+                            stack.append((nr, nc))
+                            visited.add((nr, nc))
+                max_area = max(max_area, shape)
+
+    return max_area

algorithms/graphs/maxareaofisland/test_max_area_of_island.py

@@ -1,24 +1,17 @@
 import unittest
+from typing import List
+from parameterized import parameterized
+from utils.test_utils import custom_test_name_func
+from algorithms.graphs.maxareaofisland import (
+    max_area_of_island,
+    max_area_of_island_iterative,
+)
 
-from . import max_area_of_island
-
-
-class TestMaxAreaOfIsland(unittest.TestCase):
-    def test_empty_grid(self):
-        """should return 0 for empty grid"""
-        grid = [[]]
-        expected = 0
-        self.assertEqual(max_area_of_island(grid), expected)
-
-    def test_grid_with_no_islands(self):
-        """should return 0 for grid with no islands"""
-        grid = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
-        expected = 0
-        actual = max_area_of_island(grid)
-        self.assertEqual(expected, actual)
-
-    def test_should_return_max_area_of_island(self):
-        grid = [
+MAX_AREA_OF_ISLAND_TEST_CASES = [
+    ([[]], 0),
+    ([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], 0),
+    (
+        [
             [0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
             [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
             [0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
@@ -27,10 +20,60 @@ def test_should_return_max_area_of_island(self):
             [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
             [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
             [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
-        ]
-        expected = 6
+        ],
+        6,
+    ),
+    ([[1, 1, 0], [0, 1, 0], [0, 0, 1]], 3),
+    ([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], 0),
+    ([[1, 1, 1, 1, 1], [1, 1, 1, 1, 1]], 10),
+    ([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]], 1),
+    (
+        [
+            [0, 1, 1, 0, 0, 0],
+            [0, 1, 1, 1, 0, 0],
+            [0, 0, 0, 1, 1, 1],
+            [1, 0, 0, 0, 0, 1],
+        ],
+        9,
+    ),
+]
+
+
+class TestMaxAreaOfIsland(unittest.TestCase):
+    @parameterized.expand(
+        MAX_AREA_OF_ISLAND_TEST_CASES, name_func=custom_test_name_func
+    )
+    def test_max_area_of_island_recursive(self, grid: List[List[int]], expected: int):
+        """should return 0 for empty grid"""
         actual = max_area_of_island(grid)
-        self.assertEqual(expected, actual)
+        self.assertEqual(actual, expected)
+
+    @parameterized.expand(MAX_AREA_OF_ISLAND_TEST_CASES)
+    def test_max_area_of_island_iterative(self, grid: List[List[int]], expected: int):
+        actual = max_area_of_island_iterative(grid)
+        self.assertEqual(actual, expected)
+
+    # def test_grid_with_no_islands(self):
+    #     """should return 0 for grid with no islands"""
+    #     grid = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
+    #     expected = 0
+    #     actual = max_area_of_island(grid)
+    #     self.assertEqual(expected, actual)
+    #
+    # def test_should_return_max_area_of_island(self):
+    #     grid = [
+    #         [0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+    #         [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
+    #         [0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+    #         [0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0],
+    #         [0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0],
+    #         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
+    #         [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
+    #         [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
+    #     ]
+    #     expected = 6
+    #     actual = max_area_of_island(grid)
+    #     self.assertEqual(expected, actual)
 
 
 if __name__ == "__main__":

utils/test_utils.py

@@ -0,0 +1,8 @@
+from parameterized import parameterized
+
+
+def custom_test_name_func(testcase_func, param_num, param):
+    """
+    A custom name function that displays the name of the function under test along with the arguments and parameters
+    """
+    return f"{testcase_func.__name__}, {parameterized.to_safe_name("_".join(str(x) for x in param.args))}"