feat: add 01 Matrix

Author: wislertt

.templates/leetcode/json/zero_one_matrix.json

@@ -0,0 +1,47 @@
+{
+    "problem_name": "zero_one_matrix",
+    "solution_class_name": "Solution",
+    "problem_number": "542",
+    "problem_title": "01 Matrix",
+    "difficulty": "Medium",
+    "topics": "Array, Dynamic Programming, Breadth-First Search, Matrix",
+    "tags": ["grind-75"],
+    "readme_description": "Given an `m x n` binary matrix `mat`, return the distance of the nearest `0` for each cell.\n\nThe distance between two cells sharing a common edge is `1`.",
+    "readme_examples": [
+        {
+            "content": "![Example 1](https://assets.leetcode.com/uploads/2021/04/24/01-1-grid.jpg)\n\n```\nInput: mat = [[0,0,0],[0,1,0],[0,0,0]]\nOutput: [[0,0,0],[0,1,0],[0,0,0]]\n```"
+        },
+        {
+            "content": "![Example 2](https://assets.leetcode.com/uploads/2021/04/24/01-2-grid.jpg)\n\n```\nInput: mat = [[0,0,0],[0,1,0],[1,1,1]]\nOutput: [[0,0,0],[0,1,0],[1,2,1]]\n```"
+        }
+    ],
+    "readme_constraints": "- `m == mat.length`\n- `n == mat[i].length`\n- `1 <= m, n <= 10^4`\n- `1 <= m * n <= 10^4`\n- `mat[i][j]` is either `0` or `1`\n- There is at least one `0` in `mat`",
+    "readme_additional": "**Note:** This question is the same as 1765: [Map of Highest Peak](https://leetcode.com/problems/map-of-highest-peak/)",
+    "solution_imports": "",
+    "solution_methods": [
+        {
+            "name": "update_matrix",
+            "parameters": "mat: list[list[int]]",
+            "return_type": "list[list[int]]",
+            "dummy_return": "[]"
+        }
+    ],
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .solution import Solution",
+    "test_class_name": "ZeroOneMatrix",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_update_matrix",
+            "parametrize": "mat, expected",
+            "parametrize_typed": "mat: list[list[int]], expected: list[list[int]]",
+            "test_cases": "[([[0, 0, 0], [0, 1, 0], [0, 0, 0]], [[0, 0, 0], [0, 1, 0], [0, 0, 0]]), ([[0, 0, 0], [0, 1, 0], [1, 1, 1]], [[0, 0, 0], [0, 1, 0], [1, 2, 1]])]",
+            "body": "result = self.solution.update_matrix(mat)\nassert result == expected"
+        }
+    ],
+    "playground_imports": "from solution import Solution",
+    "playground_test_case": "# Example test case\nmat = [[0, 0, 0], [0, 1, 0], [1, 1, 1]]\nexpected = [[0, 0, 0], [0, 1, 0], [1, 2, 1]]",
+    "playground_execution": "result = Solution().update_matrix(mat)\nresult",
+    "playground_assertion": "assert result == expected"
+}

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= implement_queue_using_stacks
+PROBLEM ?= zero_one_matrix
 FORCE ?= 0
 COMMA := ,
 

leetcode/zero_one_matrix/README.md

@@ -0,0 +1,44 @@
+# 01 Matrix
+
+**Difficulty:** Medium
+**Topics:** Array, Dynamic Programming, Breadth-First Search, Matrix
+**Tags:** grind-75
+
+**LeetCode:** [Problem 542](https://leetcode.com/problems/zero-one-matrix/description/)
+
+## Problem Description
+
+Given an `m x n` binary matrix `mat`, return the distance of the nearest `0` for each cell.
+
+The distance between two cells sharing a common edge is `1`.
+
+## Examples
+
+### Example 1:
+
+![Example 1](https://assets.leetcode.com/uploads/2021/04/24/01-1-grid.jpg)
+
+```
+Input: mat = [[0,0,0],[0,1,0],[0,0,0]]
+Output: [[0,0,0],[0,1,0],[0,0,0]]
+```
+
+### Example 2:
+
+![Example 2](https://assets.leetcode.com/uploads/2021/04/24/01-2-grid.jpg)
+
+```
+Input: mat = [[0,0,0],[0,1,0],[1,1,1]]
+Output: [[0,0,0],[0,1,0],[1,2,1]]
+```
+
+## Constraints
+
+- `m == mat.length`
+- `n == mat[i].length`
+- `1 <= m, n <= 10^4`
+- `1 <= m * n <= 10^4`
+- `mat[i][j]` is either `0` or `1`
+- There is at least one `0` in `mat`
+
+**Note:** This question is the same as 1765: [Map of Highest Peak](https://leetcode.com/problems/map-of-highest-peak/)

leetcode/zero_one_matrix/__init__.py

@@ -0,0 +1,57 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "imports",
+   "metadata": {},
+   "outputs": [],
+   "source": ["from solution import Solution"]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "setup",
+   "metadata": {},
+   "outputs": [],
+   "source": ["# Example test case\nmat = [[0, 0, 0], [0, 1, 0], [1, 1, 1]]\nexpected = [[0, 0, 0], [0, 1, 0], [1, 2, 1]]"]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "execute",
+   "metadata": {},
+   "outputs": [],
+   "source": ["result = Solution().update_matrix(mat)\nresult"]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "test",
+   "metadata": {},
+   "outputs": [],
+   "source": ["assert result == expected"]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "leetcode-py-py3.13",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python3",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

leetcode/zero_one_matrix/playground.ipynb

@@ -0,0 +1,30 @@
+from collections import deque
+
+
+class Solution:
+    # Time: O(m * n)
+    # Space: O(m * n)
+    def update_matrix(self, mat: list[list[int]]) -> list[list[int]]:
+        UNSEEN = -1
+        m, n = len(mat), len(mat[0])
+        queue: deque[tuple[int, int]] = deque()
+
+        # Mark 1s as UNSEEN and add all 0s to queue
+        for i in range(m):
+            for j in range(n):
+                if mat[i][j] == 0:
+                    queue.append((i, j))
+                else:
+                    mat[i][j] = UNSEEN
+
+        # BFS from all 0s simultaneously
+        directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
+        while queue:
+            row, col = queue.popleft()
+            for dr, dc in directions:
+                r, c = row + dr, col + dc
+                if 0 <= r < m and 0 <= c < n and mat[r][c] == UNSEEN:
+                    mat[r][c] = mat[row][col] + 1
+                    queue.append((r, c))
+
+        return mat

leetcode/zero_one_matrix/solution.py

@@ -0,0 +1,29 @@
+import pytest
+
+from leetcode_py.test_utils import logged_test
+
+from .solution import Solution
+
+
+class TestZeroOneMatrix:
+    def setup_method(self):
+        self.solution = Solution()
+
+    @pytest.mark.parametrize(
+        "mat, expected",
+        [
+            ([[0, 0, 0], [0, 1, 0], [0, 0, 0]], [[0, 0, 0], [0, 1, 0], [0, 0, 0]]),
+            ([[0, 0, 0], [0, 1, 0], [1, 1, 1]], [[0, 0, 0], [0, 1, 0], [1, 2, 1]]),
+            ([[0]], [[0]]),
+            ([[1, 1, 1], [1, 1, 1], [1, 1, 0]], [[4, 3, 2], [3, 2, 1], [2, 1, 0]]),
+            ([[0, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]], [[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5]]),
+            (
+                [[1, 0, 1, 1, 0, 0, 1, 0, 0, 1], [0, 1, 1, 0, 1, 0, 1, 0, 1, 1]],
+                [[1, 0, 1, 1, 0, 0, 1, 0, 0, 1], [0, 1, 1, 0, 1, 0, 1, 0, 1, 2]],
+            ),
+        ],
+    )
+    @logged_test
+    def test_update_matrix(self, mat: list[list[int]], expected: list[list[int]]):
+        result = self.solution.update_matrix(mat)
+        assert result == expected