D. J.:

- Added the leetcode problem and solution for 2435

Author: nobodyPerfecZ

README.md

@@ -302,6 +302,7 @@
 - [2215 Find the Difference of Two Arrays](https://leetcode.com/problems/find-the-difference-of-two-arrays/description/)
 - [2353 Design a Food Rating System](https://leetcode.com/problems/design-a-food-rating-system/description/)
 - [2390 Removing Stars From a String](https://leetcode.com/problems/removing-stars-from-a-string/description/)
+- [2435 Paths in Matrix Whose Sum Is Divisible by K](https://leetcode.com/problems/paths-in-matrix-whose-sum-is-divisible-by-k/description/)
 - [2466 Count Ways To Build Good Strings](https://leetcode.com/problems/count-ways-to-build-good-strings/description/)
 - [2523 Closest Prime Numbers in Range](https://leetcode.com/problems/closest-prime-numbers-in-range/description/)
 - [2785 Sort Vowels in a String](https://leetcode.com/problems/sort-vowels-in-a-string/description/)

awesome_python_leetcode/_2435_paths_in_matrix_whose_sum_is_divisible_by_k.py

@@ -0,0 +1,66 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def numberOfPathsTD(self, grid: List[List[int]], k: int) -> int:
+        """
+        You are given a 0-indexed m x n integer matrix grid and an integer k.
+        You are currently at position (0, 0) and you want to reach position
+        (m - 1, n - 1) moving only down or right.
+
+        Return the number of paths where the sum of the elements on the path is
+        divisible by k. Since the answer may be very large, return it modulo 109 + 7.
+        """
+        # Top-Down Dynamic Programming (Memoization)
+        ROWS = len(grid)
+        COLS = len(grid[0])
+        MOD = 10**9 + 7
+        dp = [[[-1] * k for _ in range(COLS)] for _ in range(ROWS)]
+
+        def dfs(row: int, col: int, remain: int):
+            if row == ROWS - 1 and col == COLS - 1:
+                remain = (grid[row][col] + remain) % k
+                return 0 if remain else 1
+            if row == ROWS or col == COLS:
+                return 0
+            if dp[row][col][remain] > -1:
+                return dp[row][col][remain]
+            dp[row][col][remain] = (
+                dfs(row + 1, col, (grid[row][col] + remain) % k) % MOD
+                + dfs(row, col + 1, (grid[row][col] + remain) % k) % MOD
+            ) % MOD
+            return dp[row][col][remain]
+
+        return dfs(0, 0, 0)
+
+    def numberOfPathsBU(self, grid: List[List[int]], k: int) -> int:
+        """
+        You are given a 0-indexed m x n integer matrix grid and an integer k.
+        You are currently at position (0, 0) and you want to reach position
+        (m - 1, n - 1) moving only down or right.
+
+        Return the number of paths where the sum of the elements on the path is
+        divisible by k. Since the answer may be very large, return it modulo 109 + 7.
+        """
+        # Bottom-Up Dynamic Programming (Tabulation)
+        ROWS = len(grid)
+        COLS = len(grid[0])
+        MOD = 10**9 + 7
+        dp = [[[0] * k for _ in range(COLS + 1)] for _ in range(ROWS + 1)]
+        target_remain = (k - (grid[ROWS - 1][COLS - 1] % k)) % k
+        dp[ROWS - 1][COLS - 1][target_remain] = 1
+
+        for row in reversed(range(ROWS)):
+            for col in reversed(range(COLS)):
+                if row == ROWS - 1 and col == COLS - 1:
+                    continue
+                for remain in range(k):
+                    new_remain = (grid[row][col] + remain) % k
+                    dp[row][col][remain] = (
+                        dp[row + 1][col][new_remain] % MOD
+                        + dp[row][col + 1][new_remain] % MOD
+                    ) % MOD
+
+        return dp[0][0][0]

tests/test_2435_paths_in_matrix_whose_sum_is_divisible_by_k.py

@@ -0,0 +1,35 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._2435_paths_in_matrix_whose_sum_is_divisible_by_k import (
+    Solution,
+)
+
+
+@pytest.mark.parametrize(
+    argnames=["grid", "k", "expected"],
+    argvalues=[
+        ([[5, 2, 4], [3, 0, 5], [0, 7, 2]], 3, 2),
+        ([[0, 0]], 5, 1),
+        ([[7, 3, 4, 9], [2, 3, 6, 2], [2, 3, 7, 0]], 1, 10),
+    ],
+)
+def test_funcTD(grid: List[List[int]], k: int, expected: int):
+    """Tests the solution of a LeetCode problem."""
+    paths = Solution().numberOfPathsTD(grid, k)
+    assert paths == expected
+
+
+@pytest.mark.parametrize(
+    argnames=["grid", "k", "expected"],
+    argvalues=[
+        ([[5, 2, 4], [3, 0, 5], [0, 7, 2]], 3, 2),
+        ([[0, 0]], 5, 1),
+        ([[7, 3, 4, 9], [2, 3, 6, 2], [2, 3, 7, 0]], 1, 10),
+    ],
+)
+def test_funcBU(grid: List[List[int]], k: int, expected: int):
+    """Tests the solution of a LeetCode problem."""
+    paths = Solution().numberOfPathsBU(grid, k)
+    assert paths == expected