Max area of island

Author: volodimyr

695.max_area_of_island/max.py

@@ -0,0 +1,56 @@
+# 695. Max area of island
+# Topics: 'Array', 'Depth-First Search', 'Breadth-First Search', 'Union Find', 'Matrix'
+# Level: 'Medium'
+
+# You are given an m x n binary matrix grid. An island is a group of 1's (representing land) connected 4-directionally (horizontal or vertical.) You may assume all four edges of the grid are surrounded by water.
+
+# 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.
+
+ 
+
+# Example 1:
+
+# 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:
+
+# Input: grid = [[0,0,0,0,0,0,0,0]]
+# Output: 0
+
+ 
+
+# Constraints:
+
+#     m == grid.length
+#     n == grid[i].length
+#     1 <= m, n <= 50
+#     grid[i][j] is either 0 or 1.
+
+from typing import List
+
+class Solution:
+    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
+        ROWS, COLS = len(grid), len(grid[0])
+        visits = set()
+        def dfs(r: int, c: int) -> int:
+            if min(r,c) < 0:
+                return 0
+            if r == ROWS or c == COLS:
+                return 0
+            if (r,c) in visits:
+                return 0
+            if grid[r][c] == 0:
+                return 0
+            visits.add((r,c))
+            return 1+ dfs(r+1, c)+dfs(r-1,c)+dfs(r, c+1)+dfs(r, c-1)
+        
+        max_area = 0
+        for row in range (ROWS):
+            for col in range (COLS):
+                if grid[row][col] == 1 and (row,col) not in visits:
+                    max_area = max(max_area, dfs(row, col))
+        return max_area

695.max_area_of_island/test_max.py

@@ -0,0 +1,141 @@
+import unittest
+from typing import List
+from max import Solution
+
+class TestMaxAreaOfIsland(unittest.TestCase):
+    
+    def setUp(self):
+        self.solution = Solution()
+    
+    def test_example_1(self):
+        """Test with example 1 from problem statement"""
+        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]
+        ]
+        self.assertEqual(self.solution.maxAreaOfIsland(grid), 6)
+    
+    def test_example_2(self):
+        """Test with all zeros (no islands)"""
+        grid = [[0,0,0,0,0,0,0,0]]
+        self.assertEqual(self.solution.maxAreaOfIsland(grid), 0)
+    
+    def test_single_cell_island(self):
+        """Test with single cell island"""
+        grid = [[1]]
+        self.assertEqual(self.solution.maxAreaOfIsland(grid), 1)
+    
+    def test_single_cell_water(self):
+        """Test with single cell water"""
+        grid = [[0]]
+        self.assertEqual(self.solution.maxAreaOfIsland(grid), 0)
+    
+    def test_entire_grid_is_island(self):
+        """Test when entire grid is one island"""
+        grid = [
+            [1, 1, 1],
+            [1, 1, 1],
+            [1, 1, 1]
+        ]
+        self.assertEqual(self.solution.maxAreaOfIsland(grid), 9)
+    
+    def test_multiple_islands_different_sizes(self):
+        """Test with multiple islands of different sizes"""
+        grid = [
+            [1, 1, 0, 0, 0],
+            [1, 1, 0, 0, 0],
+            [0, 0, 0, 1, 1],
+            [0, 0, 0, 1, 1]
+        ]
+        self.assertEqual(self.solution.maxAreaOfIsland(grid), 4)
+    
+    def test_diagonal_not_connected(self):
+        """Test that diagonal cells are not considered connected"""
+        grid = [
+            [1, 0, 1],
+            [0, 1, 0],
+            [1, 0, 1]
+        ]
+        self.assertEqual(self.solution.maxAreaOfIsland(grid), 1)
+    
+    def test_l_shaped_island(self):
+        """Test L-shaped island"""
+        grid = [
+            [1, 0, 0],
+            [1, 0, 0],
+            [1, 1, 1]
+        ]
+        self.assertEqual(self.solution.maxAreaOfIsland(grid), 5)
+    
+    def test_snake_shaped_island(self):
+        """Test snake-shaped island"""
+        grid = [
+            [1, 1, 1, 0],
+            [0, 0, 1, 0],
+            [0, 0, 1, 0],
+            [0, 1, 1, 0]
+        ]
+        self.assertEqual(self.solution.maxAreaOfIsland(grid), 7)
+    
+    def test_isolated_single_cells(self):
+        """Test multiple isolated single-cell islands"""
+        grid = [
+            [1, 0, 1, 0, 1],
+            [0, 0, 0, 0, 0],
+            [1, 0, 1, 0, 1]
+        ]
+        self.assertEqual(self.solution.maxAreaOfIsland(grid), 1)
+    
+    def test_vertical_strip(self):
+        """Test vertical strip island"""
+        grid = [
+            [0, 1, 0],
+            [0, 1, 0],
+            [0, 1, 0],
+            [0, 1, 0]
+        ]
+        self.assertEqual(self.solution.maxAreaOfIsland(grid), 4)
+    
+    def test_horizontal_strip(self):
+        """Test horizontal strip island"""
+        grid = [
+            [0, 0, 0, 0],
+            [1, 1, 1, 1],
+            [0, 0, 0, 0]
+        ]
+        self.assertEqual(self.solution.maxAreaOfIsland(grid), 4)
+    
+    def test_complex_shape(self):
+        """Test complex island shape"""
+        grid = [
+            [1, 1, 0, 1, 1],
+            [1, 0, 0, 0, 1],
+            [1, 0, 1, 0, 1],
+            [1, 1, 1, 1, 1]
+        ]
+        self.assertEqual(self.solution.maxAreaOfIsland(grid), 14)
+    
+    def test_max_constraint_size(self):
+        """Test with larger grid approaching constraint limits"""
+        grid = [[1] * 20 for _ in range(20)]
+        self.assertEqual(self.solution.maxAreaOfIsland(grid), 400)
+    
+    def test_checkerboard_pattern(self):
+        """Test checkerboard pattern (no connected islands)"""
+        grid = [
+            [1, 0, 1, 0],
+            [0, 1, 0, 1],
+            [1, 0, 1, 0],
+            [0, 1, 0, 1]
+        ]
+        self.assertEqual(self.solution.maxAreaOfIsland(grid), 1)
+
+
+if __name__ == '__main__':
+    unittest.main()