diff --git a/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/README.md b/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/README.md
index f434ee713066d..7cac048a5fed5 100644
--- a/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/README.md	
+++ b/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/README.md	
@@ -70,198 +70,23 @@ tags:
 
 <!-- solution:start -->
 
-### 方法一：记忆化搜索
+### 方法一：动态规划
 
-设计函数 `dfs(i, j, s)` 表示从 `(i, j)` 出发，初始路径和模 $k$ 的结果为 $s$ 的路径数目。
+我们记题目中的 $k$ 为 $K$，矩阵 $\textit{grid}$ 的行数和列数分别为 $m$ 和 $n$。
 
-对于每个位置 $(i, j)$，我们可以选择向右或向下移动，因此有：
-
-$$
-dfs(i, j, s) = dfs(i + 1, j, (s + grid[i][j]) \bmod k) + dfs(i, j + 1, (s + grid[i][j]) \bmod k)
-$$
-
-答案为 `dfs(0, 0, 0)`。记忆化搜索即可。
-
-时间复杂度 $O(m \times n \times k)$，空间复杂度 $O(m \times n \times k)$。其中 $m$ 和 $n$ 分别为矩阵的行数和列数，而 $k$ 为给定的整数。
-
-<!-- tabs:start -->
-
-#### Python3
-
-```python
-class Solution:
-    def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
-        @cache
-        def dfs(i, j, s):
-            if i < 0 or i >= m or j < 0 or j >= n:
-                return 0
-            s = (s + grid[i][j]) % k
-            if i == m - 1 and j == n - 1:
-                return int(s == 0)
-            ans = dfs(i + 1, j, s) + dfs(i, j + 1, s)
-            return ans % mod
-
-        m, n = len(grid), len(grid[0])
-        mod = 10**9 + 7
-        ans = dfs(0, 0, 0)
-        dfs.cache_clear()
-        return ans
-```
-
-#### Java
-
-```java
-class Solution {
-    private int m;
-    private int n;
-    private int k;
-    private static final int MOD = (int) 1e9 + 7;
-    private int[][] grid;
-    private int[][][] f;
-
-    public int numberOfPaths(int[][] grid, int k) {
-        this.grid = grid;
-        this.k = k;
-        m = grid.length;
-        n = grid[0].length;
-        f = new int[m][n][k];
-        for (var a : f) {
-            for (var b : a) {
-                Arrays.fill(b, -1);
-            }
-        }
-        return dfs(0, 0, 0);
-    }
-
-    private int dfs(int i, int j, int s) {
-        if (i < 0 || i >= m || j < 0 || j >= n) {
-            return 0;
-        }
-        s = (s + grid[i][j]) % k;
-        if (f[i][j][s] != -1) {
-            return f[i][j][s];
-        }
-        if (i == m - 1 && j == n - 1) {
-            return s == 0 ? 1 : 0;
-        }
-        int ans = dfs(i + 1, j, s) + dfs(i, j + 1, s);
-        ans %= MOD;
-        f[i][j][s] = ans;
-        return ans;
-    }
-}
-```
-
-#### C++
-
-```cpp
-class Solution {
-public:
-    int numberOfPaths(vector<vector<int>>& grid, int k) {
-        int m = grid.size(), n = grid[0].size();
-        int mod = 1e9 + 7;
-        vector<vector<vector<int>>> f(m, vector<vector<int>>(n, vector<int>(k, -1)));
-        function<int(int, int, int)> dfs;
-        dfs = [&](int i, int j, int s) {
-            if (i < 0 || i >= m || j < 0 || j >= n) return 0;
-            s = (s + grid[i][j]) % k;
-            if (i == m - 1 && j == n - 1) return s == 0 ? 1 : 0;
-            if (f[i][j][s] != -1) return f[i][j][s];
-            int ans = dfs(i + 1, j, s) + dfs(i, j + 1, s);
-            ans %= mod;
-            f[i][j][s] = ans;
-            return ans;
-        };
-        return dfs(0, 0, 0);
-    }
-};
-```
-
-#### Go
-
-```go
-func numberOfPaths(grid [][]int, k int) int {
-	m, n := len(grid), len(grid[0])
-	var mod int = 1e9 + 7
-	f := make([][][]int, m)
-	for i := range f {
-		f[i] = make([][]int, n)
-		for j := range f[i] {
-			f[i][j] = make([]int, k)
-			for x := 0; x < k; x++ {
-				f[i][j][x] = -1
-			}
-		}
-	}
-	var dfs func(i, j, s int) int
-	dfs = func(i, j, s int) int {
-		if i < 0 || i >= m || j < 0 || j >= n {
-			return 0
-		}
-		s = (s + grid[i][j]) % k
-		if i == m-1 && j == n-1 {
-			if s == 0 {
-				return 1
-			}
-			return 0
-		}
-		if f[i][j][s] != -1 {
-			return f[i][j][s]
-		}
-		ans := dfs(i+1, j, s) + dfs(i, j+1, s)
-		ans %= mod
-		f[i][j][s] = ans
-		return ans
-	}
-	return dfs(0, 0, 0)
-}
-```
-
-#### TypeScript
-
-```ts
-function numberOfPaths(grid: number[][], k: number): number {
-    const MOD = 10 ** 9 + 7;
-    const m = grid.length,
-        n = grid[0].length;
-    let ans = Array.from({ length: m + 1 }, () =>
-        Array.from({ length: n + 1 }, () => new Array(k).fill(0)),
-    );
-    ans[0][1][0] = 1;
-    for (let i = 0; i < m; i++) {
-        for (let j = 0; j < n; j++) {
-            for (let v = 0; v < k; v++) {
-                let key = (grid[i][j] + v) % k;
-                ans[i + 1][j + 1][key] =
-                    (ans[i][j + 1][v] + ans[i + 1][j][v] + ans[i + 1][j + 1][key]) % MOD;
-            }
-        }
-    }
-    return ans[m][n][0];
-}
-```
-
-<!-- tabs:end -->
-
-<!-- solution:end -->
-
-<!-- solution:start -->
-
-### 方法二：动态规划
-
-我们也可以使用动态规划求解。
-
-定义状态 $dp[i][j][s]$ 表示从起点 $(0, 0)$ 出发，到达位置 $(i, j)$，路径和模 $k$ 等于 $s$ 的路径数目。
-
-初始值 $dp[0][0][grid[0][0] \bmod k] = 1$，答案为 $dp[m - 1][n - 1][0]$。
+定义 $f[i][j][k]$ 表示从起点 $(0, 0)$ 出发，到达位置 $(i, j)$，且路径上元素和对 $K$ 取模等于 $k$ 的路径数目。初始时，$f[0][0][\textit{grid}[0][0] \bmod K] = 1$。 最终答案即为 $f[m - 1][n - 1][0]$。
 
 我们可以得到状态转移方程：
 
 $$
-dp[i][j][s] = dp[i - 1][j][(s - grid[i][j])\bmod k] + dp[i][j - 1][(s - grid[i][j])\bmod k]
+f[i][j][k] = f[i - 1][j][(k - \textit{grid}[i][j])\bmod K] + f[i][j - 1][(k - \textit{grid}[i][j])\bmod K]
 $$
 
-时间复杂度 $O(m \times n \times k)$，空间复杂度 $O(m \times n \times k)$。其中 $m$ 和 $n$ 分别为矩阵的行数和列数，而 $k$ 为给定的整数。
+为了避免负数取模的问题，我们可以将上式中的 $(k - \textit{grid}[i][j])\bmod K$ 替换为 $((k - \textit{grid}[i][j] \bmod K) + K) \bmod K$。
+
+答案即为 $f[m - 1][n - 1][0]$。
+
+时间复杂度 $O(m \times n \times K)$，空间复杂度 $O(m \times n \times K)$。其中 $m$ 和 $n$ 分别是矩阵 $\textit{grid}$ 的行数和列数，而 $K$ 是题目中的整数 $k$。
 
 <!-- tabs:start -->
 
@@ -269,48 +94,46 @@ $$
 
 ```python
 class Solution:
-    def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
-        m, n = len(grid), len(grid[0])
-        dp = [[[0] * k for _ in range(n)] for _ in range(m)]
-        dp[0][0][grid[0][0] % k] = 1
+    def numberOfPaths(self, grid: List[List[int]], K: int) -> int:
         mod = 10**9 + 7
+        m, n = len(grid), len(grid[0])
+        f = [[[0] * K for _ in range(n)] for _ in range(m)]
+        f[0][0][grid[0][0] % K] = 1
         for i in range(m):
             for j in range(n):
-                for s in range(k):
-                    t = ((s - grid[i][j] % k) + k) % k
+                for k in range(K):
+                    k0 = ((k - grid[i][j] % K) + K) % K
                     if i:
-                        dp[i][j][s] += dp[i - 1][j][t]
+                        f[i][j][k] += f[i - 1][j][k0]
                     if j:
-                        dp[i][j][s] += dp[i][j - 1][t]
-                    dp[i][j][s] %= mod
-        return dp[-1][-1][0]
+                        f[i][j][k] += f[i][j - 1][k0]
+                    f[i][j][k] %= mod
+        return f[m - 1][n - 1][0]
 ```
 
 #### Java
 
 ```java
 class Solution {
-    private static final int MOD = (int) 1e9 + 7;
-
-    public int numberOfPaths(int[][] grid, int k) {
+    public int numberOfPaths(int[][] grid, int K) {
+        final int mod = (int) 1e9 + 7;
         int m = grid.length, n = grid[0].length;
-        int[][][] dp = new int[m][n][k];
-        dp[0][0][grid[0][0] % k] = 1;
+        int[][][] f = new int[m][n][K];
+        f[0][0][grid[0][0] % K] = 1;
         for (int i = 0; i < m; ++i) {
             for (int j = 0; j < n; ++j) {
-                for (int s = 0; s < k; ++s) {
-                    int t = ((s - grid[i][j] % k) + k) % k;
+                for (int k = 0; k < K; ++k) {
+                    int k0 = ((k - grid[i][j] % K) + K) % K;
                     if (i > 0) {
-                        dp[i][j][s] += dp[i - 1][j][t];
+                        f[i][j][k] = (f[i][j][k] + f[i - 1][j][k0]) % mod;
                     }
                     if (j > 0) {
-                        dp[i][j][s] += dp[i][j - 1][t];
+                        f[i][j][k] = (f[i][j][k] + f[i][j - 1][k0]) % mod;
                     }
-                    dp[i][j][s] %= MOD;
                 }
             }
         }
-        return dp[m - 1][n - 1][0];
+        return f[m - 1][n - 1][0];
     }
 }
 ```
@@ -320,23 +143,26 @@ class Solution {
 ```cpp
 class Solution {
 public:
-    const int mod = 1e9 + 7;
-
-    int numberOfPaths(vector<vector<int>>& grid, int k) {
+    int numberOfPaths(vector<vector<int>>& grid, int K) {
+        const int mod = 1e9 + 7;
         int m = grid.size(), n = grid[0].size();
-        vector<vector<vector<int>>> dp(m, vector<vector<int>>(n, vector<int>(k)));
-        dp[0][0][grid[0][0] % k] = 1;
+        int f[m][n][K];
+        memset(f, 0, sizeof(f));
+        f[0][0][grid[0][0] % K] = 1;
         for (int i = 0; i < m; ++i) {
             for (int j = 0; j < n; ++j) {
-                for (int s = 0; s < k; ++s) {
-                    int t = ((s - grid[i][j] % k) + k) % k;
-                    if (i) dp[i][j][s] += dp[i - 1][j][t];
-                    if (j) dp[i][j][s] += dp[i][j - 1][t];
-                    dp[i][j][s] %= mod;
+                for (int k = 0; k < K; ++k) {
+                    int k0 = ((k - grid[i][j] % K) + K) % K;
+                    if (i > 0) {
+                        f[i][j][k] = (f[i][j][k] + f[i - 1][j][k0]) % mod;
+                    }
+                    if (j > 0) {
+                        f[i][j][k] = (f[i][j][k] + f[i][j - 1][k0]) % mod;
+                    }
                 }
             }
         }
-        return dp[m - 1][n - 1][0];
+        return f[m - 1][n - 1][0];
     }
 };
 ```
@@ -344,32 +170,88 @@ public:
 #### Go
 
 ```go
-func numberOfPaths(grid [][]int, k int) int {
+func numberOfPaths(grid [][]int, K int) int {
+	const mod = 1e9 + 7
 	m, n := len(grid), len(grid[0])
-	var mod int = 1e9 + 7
-	dp := make([][][]int, m)
-	for i := range dp {
-		dp[i] = make([][]int, n)
-		for j := range dp[i] {
-			dp[i][j] = make([]int, k)
+	f := make([][][]int, m)
+	for i := range f {
+		f[i] = make([][]int, n)
+		for j := range f[i] {
+			f[i][j] = make([]int, K)
 		}
 	}
-	dp[0][0][grid[0][0]%k] = 1
+	f[0][0][grid[0][0]%K] = 1
 	for i := 0; i < m; i++ {
 		for j := 0; j < n; j++ {
-			for s := 0; s < k; s++ {
-				t := ((s - grid[i][j]%k) + k) % k
+			for k := 0; k < K; k++ {
+				k0 := ((k - grid[i][j]%K) + K) % K
 				if i > 0 {
-					dp[i][j][s] += dp[i-1][j][t]
+					f[i][j][k] = (f[i][j][k] + f[i-1][j][k0]) % mod
 				}
 				if j > 0 {
-					dp[i][j][s] += dp[i][j-1][t]
+					f[i][j][k] = (f[i][j][k] + f[i][j-1][k0]) % mod
 				}
-				dp[i][j][s] %= mod
 			}
 		}
 	}
-	return dp[m-1][n-1][0]
+	return f[m-1][n-1][0]
+}
+```
+
+#### TypeScript
+
+```ts
+function numberOfPaths(grid: number[][], K: number): number {
+    const mod = 1e9 + 7;
+    const m = grid.length;
+    const n = grid[0].length;
+    const f: number[][][] = Array.from({ length: m }, () =>
+        Array.from({ length: n }, () => Array(K).fill(0)),
+    );
+    f[0][0][grid[0][0] % K] = 1;
+    for (let i = 0; i < m; ++i) {
+        for (let j = 0; j < n; ++j) {
+            for (let k = 0; k < K; ++k) {
+                const k0 = (k - (grid[i][j] % K) + K) % K;
+                if (i > 0) {
+                    f[i][j][k] = (f[i][j][k] + f[i - 1][j][k0]) % mod;
+                }
+                if (j > 0) {
+                    f[i][j][k] = (f[i][j][k] + f[i][j - 1][k0]) % mod;
+                }
+            }
+        }
+    }
+    return f[m - 1][n - 1][0];
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+    pub fn number_of_paths(grid: Vec<Vec<i32>>, K: i32) -> i32 {
+        const MOD: i32 = 1_000_000_007;
+        let m = grid.len();
+        let n = grid[0].len();
+        let K = K as usize;
+        let mut f = vec![vec![vec![0; K]; n]; m];
+        f[0][0][grid[0][0] as usize % K] = 1;
+        for i in 0..m {
+            for j in 0..n {
+                for k in 0..K {
+                    let k0 = ((k + K - grid[i][j] as usize % K) % K) as usize;
+                    if i > 0 {
+                        f[i][j][k] = (f[i][j][k] + f[i - 1][j][k0]) % MOD;
+                    }
+                    if j > 0 {
+                        f[i][j][k] = (f[i][j][k] + f[i][j - 1][k0]) % MOD;
+                    }
+                }
+            }
+        }
+        f[m - 1][n - 1][0]
+    }
 }
 ```
 
diff --git a/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/README_EN.md b/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/README_EN.md
index 3958a01ea6b17..e85d0a014a6d2 100644
--- a/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/README_EN.md	
+++ b/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/README_EN.md	
@@ -69,198 +69,23 @@ The second path highlighted in blue has a sum of 5 + 3 + 0 + 5 + 2 = 15 which is
 
 <!-- solution:start -->
 
-### Solution 1: Memoization Search
+### Solution 1: Dynamic Programming
 
-We design a function `dfs(i, j, s)` to represent the number of paths starting from `(i, j)` with an initial path sum modulo $k$ equal to $s$.
+We denote the $k$ in the problem as $K$, and let $m$ and $n$ be the number of rows and columns of the matrix $\textit{grid}$, respectively.
 
-For each position $(i, j)$, we can choose to move right or down, so we have:
+Define $f[i][j][k]$ as the number of paths starting from $(0, 0)$, reaching position $(i, j)$, where the sum of elements along the path modulo $K$ equals $k$. Initially, $f[0][0][\textit{grid}[0][0] \bmod K] = 1$. The final answer is $f[m - 1][n - 1][0]$.
+
+We can derive the state transition equation:
 
 $$
-dfs(i, j, s) = dfs(i + 1, j, (s + grid[i][j]) \bmod k) + dfs(i, j + 1, (s + grid[i][j]) \bmod k)
+f[i][j][k] = f[i - 1][j][(k - \textit{grid}[i][j])\bmod K] + f[i][j - 1][(k - \textit{grid}[i][j])\bmod K]
 $$
 
-The answer is `dfs(0, 0, 0)`. We can use memoization search.
-
-The time complexity is $O(m \times n \times k)$, and the space complexity is $O(m \times n \times k)$. Here, $m$ and $n$ are the number of rows and columns of the matrix, and $k$ is the given integer.
-
-<!-- tabs:start -->
-
-#### Python3
-
-```python
-class Solution:
-    def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
-        @cache
-        def dfs(i, j, s):
-            if i < 0 or i >= m or j < 0 or j >= n:
-                return 0
-            s = (s + grid[i][j]) % k
-            if i == m - 1 and j == n - 1:
-                return int(s == 0)
-            ans = dfs(i + 1, j, s) + dfs(i, j + 1, s)
-            return ans % mod
-
-        m, n = len(grid), len(grid[0])
-        mod = 10**9 + 7
-        ans = dfs(0, 0, 0)
-        dfs.cache_clear()
-        return ans
-```
-
-#### Java
+To avoid issues with negative modulo operations, we can replace $(k - \textit{grid}[i][j])\bmod K$ in the above equation with $((k - \textit{grid}[i][j] \bmod K) + K) \bmod K$.
 
-```java
-class Solution {
-    private int m;
-    private int n;
-    private int k;
-    private static final int MOD = (int) 1e9 + 7;
-    private int[][] grid;
-    private int[][][] f;
-
-    public int numberOfPaths(int[][] grid, int k) {
-        this.grid = grid;
-        this.k = k;
-        m = grid.length;
-        n = grid[0].length;
-        f = new int[m][n][k];
-        for (var a : f) {
-            for (var b : a) {
-                Arrays.fill(b, -1);
-            }
-        }
-        return dfs(0, 0, 0);
-    }
-
-    private int dfs(int i, int j, int s) {
-        if (i < 0 || i >= m || j < 0 || j >= n) {
-            return 0;
-        }
-        s = (s + grid[i][j]) % k;
-        if (f[i][j][s] != -1) {
-            return f[i][j][s];
-        }
-        if (i == m - 1 && j == n - 1) {
-            return s == 0 ? 1 : 0;
-        }
-        int ans = dfs(i + 1, j, s) + dfs(i, j + 1, s);
-        ans %= MOD;
-        f[i][j][s] = ans;
-        return ans;
-    }
-}
-```
-
-#### C++
+The answer is $f[m - 1][n - 1][0]$.
 
-```cpp
-class Solution {
-public:
-    int numberOfPaths(vector<vector<int>>& grid, int k) {
-        int m = grid.size(), n = grid[0].size();
-        int mod = 1e9 + 7;
-        vector<vector<vector<int>>> f(m, vector<vector<int>>(n, vector<int>(k, -1)));
-        function<int(int, int, int)> dfs;
-        dfs = [&](int i, int j, int s) {
-            if (i < 0 || i >= m || j < 0 || j >= n) return 0;
-            s = (s + grid[i][j]) % k;
-            if (i == m - 1 && j == n - 1) return s == 0 ? 1 : 0;
-            if (f[i][j][s] != -1) return f[i][j][s];
-            int ans = dfs(i + 1, j, s) + dfs(i, j + 1, s);
-            ans %= mod;
-            f[i][j][s] = ans;
-            return ans;
-        };
-        return dfs(0, 0, 0);
-    }
-};
-```
-
-#### Go
-
-```go
-func numberOfPaths(grid [][]int, k int) int {
-	m, n := len(grid), len(grid[0])
-	var mod int = 1e9 + 7
-	f := make([][][]int, m)
-	for i := range f {
-		f[i] = make([][]int, n)
-		for j := range f[i] {
-			f[i][j] = make([]int, k)
-			for x := 0; x < k; x++ {
-				f[i][j][x] = -1
-			}
-		}
-	}
-	var dfs func(i, j, s int) int
-	dfs = func(i, j, s int) int {
-		if i < 0 || i >= m || j < 0 || j >= n {
-			return 0
-		}
-		s = (s + grid[i][j]) % k
-		if i == m-1 && j == n-1 {
-			if s == 0 {
-				return 1
-			}
-			return 0
-		}
-		if f[i][j][s] != -1 {
-			return f[i][j][s]
-		}
-		ans := dfs(i+1, j, s) + dfs(i, j+1, s)
-		ans %= mod
-		f[i][j][s] = ans
-		return ans
-	}
-	return dfs(0, 0, 0)
-}
-```
-
-#### TypeScript
-
-```ts
-function numberOfPaths(grid: number[][], k: number): number {
-    const MOD = 10 ** 9 + 7;
-    const m = grid.length,
-        n = grid[0].length;
-    let ans = Array.from({ length: m + 1 }, () =>
-        Array.from({ length: n + 1 }, () => new Array(k).fill(0)),
-    );
-    ans[0][1][0] = 1;
-    for (let i = 0; i < m; i++) {
-        for (let j = 0; j < n; j++) {
-            for (let v = 0; v < k; v++) {
-                let key = (grid[i][j] + v) % k;
-                ans[i + 1][j + 1][key] =
-                    (ans[i][j + 1][v] + ans[i + 1][j][v] + ans[i + 1][j + 1][key]) % MOD;
-            }
-        }
-    }
-    return ans[m][n][0];
-}
-```
-
-<!-- tabs:end -->
-
-<!-- solution:end -->
-
-<!-- solution:start -->
-
-### Solution 2: Dynamic Programming
-
-We can also use dynamic programming to solve this problem.
-
-Define the state $dp[i][j][s]$ to represent the number of paths from the starting point $(0, 0)$ to the position $(i, j)$, where the path sum modulo $k$ equals $s$.
-
-The initial value is $dp[0][0][grid[0][0] \bmod k] = 1$, and the answer is $dp[m - 1][n - 1][0]$.
-
-We can get the state transition equation:
-
-$$
-dp[i][j][s] = dp[i - 1][j][(s - grid[i][j])\bmod k] + dp[i][j - 1][(s - grid[i][j])\bmod k]
-$$
-
-The time complexity is $O(m \times n \times k)$, and the space complexity is $O(m \times n \times k)$. Here, $m$ and $n$ are the number of rows and columns of the matrix, and $k$ is the given integer.
+The time complexity is $O(m \times n \times K)$ and the space complexity is $O(m \times n \times K)$, where $m$ and $n$ are the number of rows and columns of the matrix $\textit{grid}$, respectively, and $K$ is the integer $k$ from the problem.
 
 <!-- tabs:start -->
 
@@ -268,48 +93,46 @@ The time complexity is $O(m \times n \times k)$, and the space complexity is $O(
 
 ```python
 class Solution:
-    def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
-        m, n = len(grid), len(grid[0])
-        dp = [[[0] * k for _ in range(n)] for _ in range(m)]
-        dp[0][0][grid[0][0] % k] = 1
+    def numberOfPaths(self, grid: List[List[int]], K: int) -> int:
         mod = 10**9 + 7
+        m, n = len(grid), len(grid[0])
+        f = [[[0] * K for _ in range(n)] for _ in range(m)]
+        f[0][0][grid[0][0] % K] = 1
         for i in range(m):
             for j in range(n):
-                for s in range(k):
-                    t = ((s - grid[i][j] % k) + k) % k
+                for k in range(K):
+                    k0 = ((k - grid[i][j] % K) + K) % K
                     if i:
-                        dp[i][j][s] += dp[i - 1][j][t]
+                        f[i][j][k] += f[i - 1][j][k0]
                     if j:
-                        dp[i][j][s] += dp[i][j - 1][t]
-                    dp[i][j][s] %= mod
-        return dp[-1][-1][0]
+                        f[i][j][k] += f[i][j - 1][k0]
+                    f[i][j][k] %= mod
+        return f[m - 1][n - 1][0]
 ```
 
 #### Java
 
 ```java
 class Solution {
-    private static final int MOD = (int) 1e9 + 7;
-
-    public int numberOfPaths(int[][] grid, int k) {
+    public int numberOfPaths(int[][] grid, int K) {
+        final int mod = (int) 1e9 + 7;
         int m = grid.length, n = grid[0].length;
-        int[][][] dp = new int[m][n][k];
-        dp[0][0][grid[0][0] % k] = 1;
+        int[][][] f = new int[m][n][K];
+        f[0][0][grid[0][0] % K] = 1;
         for (int i = 0; i < m; ++i) {
             for (int j = 0; j < n; ++j) {
-                for (int s = 0; s < k; ++s) {
-                    int t = ((s - grid[i][j] % k) + k) % k;
+                for (int k = 0; k < K; ++k) {
+                    int k0 = ((k - grid[i][j] % K) + K) % K;
                     if (i > 0) {
-                        dp[i][j][s] += dp[i - 1][j][t];
+                        f[i][j][k] = (f[i][j][k] + f[i - 1][j][k0]) % mod;
                     }
                     if (j > 0) {
-                        dp[i][j][s] += dp[i][j - 1][t];
+                        f[i][j][k] = (f[i][j][k] + f[i][j - 1][k0]) % mod;
                     }
-                    dp[i][j][s] %= MOD;
                 }
             }
         }
-        return dp[m - 1][n - 1][0];
+        return f[m - 1][n - 1][0];
     }
 }
 ```
@@ -319,23 +142,26 @@ class Solution {
 ```cpp
 class Solution {
 public:
-    const int mod = 1e9 + 7;
-
-    int numberOfPaths(vector<vector<int>>& grid, int k) {
+    int numberOfPaths(vector<vector<int>>& grid, int K) {
+        const int mod = 1e9 + 7;
         int m = grid.size(), n = grid[0].size();
-        vector<vector<vector<int>>> dp(m, vector<vector<int>>(n, vector<int>(k)));
-        dp[0][0][grid[0][0] % k] = 1;
+        int f[m][n][K];
+        memset(f, 0, sizeof(f));
+        f[0][0][grid[0][0] % K] = 1;
         for (int i = 0; i < m; ++i) {
             for (int j = 0; j < n; ++j) {
-                for (int s = 0; s < k; ++s) {
-                    int t = ((s - grid[i][j] % k) + k) % k;
-                    if (i) dp[i][j][s] += dp[i - 1][j][t];
-                    if (j) dp[i][j][s] += dp[i][j - 1][t];
-                    dp[i][j][s] %= mod;
+                for (int k = 0; k < K; ++k) {
+                    int k0 = ((k - grid[i][j] % K) + K) % K;
+                    if (i > 0) {
+                        f[i][j][k] = (f[i][j][k] + f[i - 1][j][k0]) % mod;
+                    }
+                    if (j > 0) {
+                        f[i][j][k] = (f[i][j][k] + f[i][j - 1][k0]) % mod;
+                    }
                 }
             }
         }
-        return dp[m - 1][n - 1][0];
+        return f[m - 1][n - 1][0];
     }
 };
 ```
@@ -343,32 +169,88 @@ public:
 #### Go
 
 ```go
-func numberOfPaths(grid [][]int, k int) int {
+func numberOfPaths(grid [][]int, K int) int {
+	const mod = 1e9 + 7
 	m, n := len(grid), len(grid[0])
-	var mod int = 1e9 + 7
-	dp := make([][][]int, m)
-	for i := range dp {
-		dp[i] = make([][]int, n)
-		for j := range dp[i] {
-			dp[i][j] = make([]int, k)
+	f := make([][][]int, m)
+	for i := range f {
+		f[i] = make([][]int, n)
+		for j := range f[i] {
+			f[i][j] = make([]int, K)
 		}
 	}
-	dp[0][0][grid[0][0]%k] = 1
+	f[0][0][grid[0][0]%K] = 1
 	for i := 0; i < m; i++ {
 		for j := 0; j < n; j++ {
-			for s := 0; s < k; s++ {
-				t := ((s - grid[i][j]%k) + k) % k
+			for k := 0; k < K; k++ {
+				k0 := ((k - grid[i][j]%K) + K) % K
 				if i > 0 {
-					dp[i][j][s] += dp[i-1][j][t]
+					f[i][j][k] = (f[i][j][k] + f[i-1][j][k0]) % mod
 				}
 				if j > 0 {
-					dp[i][j][s] += dp[i][j-1][t]
+					f[i][j][k] = (f[i][j][k] + f[i][j-1][k0]) % mod
 				}
-				dp[i][j][s] %= mod
 			}
 		}
 	}
-	return dp[m-1][n-1][0]
+	return f[m-1][n-1][0]
+}
+```
+
+#### TypeScript
+
+```ts
+function numberOfPaths(grid: number[][], K: number): number {
+    const mod = 1e9 + 7;
+    const m = grid.length;
+    const n = grid[0].length;
+    const f: number[][][] = Array.from({ length: m }, () =>
+        Array.from({ length: n }, () => Array(K).fill(0)),
+    );
+    f[0][0][grid[0][0] % K] = 1;
+    for (let i = 0; i < m; ++i) {
+        for (let j = 0; j < n; ++j) {
+            for (let k = 0; k < K; ++k) {
+                const k0 = (k - (grid[i][j] % K) + K) % K;
+                if (i > 0) {
+                    f[i][j][k] = (f[i][j][k] + f[i - 1][j][k0]) % mod;
+                }
+                if (j > 0) {
+                    f[i][j][k] = (f[i][j][k] + f[i][j - 1][k0]) % mod;
+                }
+            }
+        }
+    }
+    return f[m - 1][n - 1][0];
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+    pub fn number_of_paths(grid: Vec<Vec<i32>>, K: i32) -> i32 {
+        const MOD: i32 = 1_000_000_007;
+        let m = grid.len();
+        let n = grid[0].len();
+        let K = K as usize;
+        let mut f = vec![vec![vec![0; K]; n]; m];
+        f[0][0][grid[0][0] as usize % K] = 1;
+        for i in 0..m {
+            for j in 0..n {
+                for k in 0..K {
+                    let k0 = ((k + K - grid[i][j] as usize % K) % K) as usize;
+                    if i > 0 {
+                        f[i][j][k] = (f[i][j][k] + f[i - 1][j][k0]) % MOD;
+                    }
+                    if j > 0 {
+                        f[i][j][k] = (f[i][j][k] + f[i][j - 1][k0]) % MOD;
+                    }
+                }
+            }
+        }
+        f[m - 1][n - 1][0]
+    }
 }
 ```
 
diff --git a/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution.cpp b/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution.cpp
index 6178d054221cb..c0195bc6c24e7 100644
--- a/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution.cpp	
+++ b/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution.cpp	
@@ -1,20 +1,24 @@
 class Solution {
 public:
-    int numberOfPaths(vector<vector<int>>& grid, int k) {
+    int numberOfPaths(vector<vector<int>>& grid, int K) {
+        const int mod = 1e9 + 7;
         int m = grid.size(), n = grid[0].size();
-        int mod = 1e9 + 7;
-        vector<vector<vector<int>>> f(m, vector<vector<int>>(n, vector<int>(k, -1)));
-        function<int(int, int, int)> dfs;
-        dfs = [&](int i, int j, int s) {
-            if (i < 0 || i >= m || j < 0 || j >= n) return 0;
-            s = (s + grid[i][j]) % k;
-            if (i == m - 1 && j == n - 1) return s == 0 ? 1 : 0;
-            if (f[i][j][s] != -1) return f[i][j][s];
-            int ans = dfs(i + 1, j, s) + dfs(i, j + 1, s);
-            ans %= mod;
-            f[i][j][s] = ans;
-            return ans;
-        };
-        return dfs(0, 0, 0);
+        int f[m][n][K];
+        memset(f, 0, sizeof(f));
+        f[0][0][grid[0][0] % K] = 1;
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                for (int k = 0; k < K; ++k) {
+                    int k0 = ((k - grid[i][j] % K) + K) % K;
+                    if (i > 0) {
+                        f[i][j][k] = (f[i][j][k] + f[i - 1][j][k0]) % mod;
+                    }
+                    if (j > 0) {
+                        f[i][j][k] = (f[i][j][k] + f[i][j - 1][k0]) % mod;
+                    }
+                }
+            }
+        }
+        return f[m - 1][n - 1][0];
     }
-};
\ No newline at end of file
+};
diff --git a/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution.go b/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution.go
index 23ba08d6e7180..d838df2a72079 100644
--- a/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution.go	
+++ b/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution.go	
@@ -1,35 +1,26 @@
-func numberOfPaths(grid [][]int, k int) int {
+func numberOfPaths(grid [][]int, K int) int {
+	const mod = 1e9 + 7
 	m, n := len(grid), len(grid[0])
-	var mod int = 1e9 + 7
 	f := make([][][]int, m)
 	for i := range f {
 		f[i] = make([][]int, n)
 		for j := range f[i] {
-			f[i][j] = make([]int, k)
-			for x := 0; x < k; x++ {
-				f[i][j][x] = -1
-			}
+			f[i][j] = make([]int, K)
 		}
 	}
-	var dfs func(i, j, s int) int
-	dfs = func(i, j, s int) int {
-		if i < 0 || i >= m || j < 0 || j >= n {
-			return 0
-		}
-		s = (s + grid[i][j]) % k
-		if i == m-1 && j == n-1 {
-			if s == 0 {
-				return 1
+	f[0][0][grid[0][0]%K] = 1
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			for k := 0; k < K; k++ {
+				k0 := ((k - grid[i][j]%K) + K) % K
+				if i > 0 {
+					f[i][j][k] = (f[i][j][k] + f[i-1][j][k0]) % mod
+				}
+				if j > 0 {
+					f[i][j][k] = (f[i][j][k] + f[i][j-1][k0]) % mod
+				}
 			}
-			return 0
-		}
-		if f[i][j][s] != -1 {
-			return f[i][j][s]
 		}
-		ans := dfs(i+1, j, s) + dfs(i, j+1, s)
-		ans %= mod
-		f[i][j][s] = ans
-		return ans
 	}
-	return dfs(0, 0, 0)
-}
\ No newline at end of file
+	return f[m-1][n-1][0]
+}
diff --git a/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution.java b/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution.java
index 2493a1990a396..1a5bf5992379f 100644
--- a/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution.java	
+++ b/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution.java	
@@ -1,39 +1,22 @@
 class Solution {
-    private int m;
-    private int n;
-    private int k;
-    private static final int MOD = (int) 1e9 + 7;
-    private int[][] grid;
-    private int[][][] f;
-
-    public int numberOfPaths(int[][] grid, int k) {
-        this.grid = grid;
-        this.k = k;
-        m = grid.length;
-        n = grid[0].length;
-        f = new int[m][n][k];
-        for (var a : f) {
-            for (var b : a) {
-                Arrays.fill(b, -1);
+    public int numberOfPaths(int[][] grid, int K) {
+        final int mod = (int) 1e9 + 7;
+        int m = grid.length, n = grid[0].length;
+        int[][][] f = new int[m][n][K];
+        f[0][0][grid[0][0] % K] = 1;
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                for (int k = 0; k < K; ++k) {
+                    int k0 = ((k - grid[i][j] % K) + K) % K;
+                    if (i > 0) {
+                        f[i][j][k] = (f[i][j][k] + f[i - 1][j][k0]) % mod;
+                    }
+                    if (j > 0) {
+                        f[i][j][k] = (f[i][j][k] + f[i][j - 1][k0]) % mod;
+                    }
+                }
             }
         }
-        return dfs(0, 0, 0);
+        return f[m - 1][n - 1][0];
     }
-
-    private int dfs(int i, int j, int s) {
-        if (i < 0 || i >= m || j < 0 || j >= n) {
-            return 0;
-        }
-        s = (s + grid[i][j]) % k;
-        if (f[i][j][s] != -1) {
-            return f[i][j][s];
-        }
-        if (i == m - 1 && j == n - 1) {
-            return s == 0 ? 1 : 0;
-        }
-        int ans = dfs(i + 1, j, s) + dfs(i, j + 1, s);
-        ans %= MOD;
-        f[i][j][s] = ans;
-        return ans;
-    }
-}
\ No newline at end of file
+}
diff --git a/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution.py b/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution.py
index 6233faa28ca8e..47cff55ee1127 100644
--- a/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution.py	
+++ b/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution.py	
@@ -1,17 +1,16 @@
 class Solution:
-    def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
-        @cache
-        def dfs(i, j, s):
-            if i < 0 or i >= m or j < 0 or j >= n:
-                return 0
-            s = (s + grid[i][j]) % k
-            if i == m - 1 and j == n - 1:
-                return int(s == 0)
-            ans = dfs(i + 1, j, s) + dfs(i, j + 1, s)
-            return ans % mod
-
-        m, n = len(grid), len(grid[0])
+    def numberOfPaths(self, grid: List[List[int]], K: int) -> int:
         mod = 10**9 + 7
-        ans = dfs(0, 0, 0)
-        dfs.cache_clear()
-        return ans
+        m, n = len(grid), len(grid[0])
+        f = [[[0] * K for _ in range(n)] for _ in range(m)]
+        f[0][0][grid[0][0] % K] = 1
+        for i in range(m):
+            for j in range(n):
+                for k in range(K):
+                    k0 = ((k - grid[i][j] % K) + K) % K
+                    if i:
+                        f[i][j][k] += f[i - 1][j][k0]
+                    if j:
+                        f[i][j][k] += f[i][j - 1][k0]
+                    f[i][j][k] %= mod
+        return f[m - 1][n - 1][0]
diff --git a/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution.rs b/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution.rs
new file mode 100644
index 0000000000000..30026ce9b4adc
--- /dev/null
+++ b/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution.rs	
@@ -0,0 +1,24 @@
+impl Solution {
+    pub fn number_of_paths(grid: Vec<Vec<i32>>, K: i32) -> i32 {
+        const MOD: i32 = 1_000_000_007;
+        let m = grid.len();
+        let n = grid[0].len();
+        let K = K as usize;
+        let mut f = vec![vec![vec![0; K]; n]; m];
+        f[0][0][grid[0][0] as usize % K] = 1;
+        for i in 0..m {
+            for j in 0..n {
+                for k in 0..K {
+                    let k0 = ((k + K - grid[i][j] as usize % K) % K) as usize;
+                    if i > 0 {
+                        f[i][j][k] = (f[i][j][k] + f[i - 1][j][k0]) % MOD;
+                    }
+                    if j > 0 {
+                        f[i][j][k] = (f[i][j][k] + f[i][j - 1][k0]) % MOD;
+                    }
+                }
+            }
+        }
+        f[m - 1][n - 1][0]
+    }
+}
diff --git a/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution.ts b/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution.ts
index 7171127efa93f..5b08f2e2a5878 100644
--- a/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution.ts	
+++ b/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution.ts	
@@ -1,19 +1,23 @@
-function numberOfPaths(grid: number[][], k: number): number {
-    const MOD = 10 ** 9 + 7;
-    const m = grid.length,
-        n = grid[0].length;
-    let ans = Array.from({ length: m + 1 }, () =>
-        Array.from({ length: n + 1 }, () => new Array(k).fill(0)),
+function numberOfPaths(grid: number[][], K: number): number {
+    const mod = 1e9 + 7;
+    const m = grid.length;
+    const n = grid[0].length;
+    const f: number[][][] = Array.from({ length: m }, () =>
+        Array.from({ length: n }, () => Array(K).fill(0)),
     );
-    ans[0][1][0] = 1;
-    for (let i = 0; i < m; i++) {
-        for (let j = 0; j < n; j++) {
-            for (let v = 0; v < k; v++) {
-                let key = (grid[i][j] + v) % k;
-                ans[i + 1][j + 1][key] =
-                    (ans[i][j + 1][v] + ans[i + 1][j][v] + ans[i + 1][j + 1][key]) % MOD;
+    f[0][0][grid[0][0] % K] = 1;
+    for (let i = 0; i < m; ++i) {
+        for (let j = 0; j < n; ++j) {
+            for (let k = 0; k < K; ++k) {
+                const k0 = (k - (grid[i][j] % K) + K) % K;
+                if (i > 0) {
+                    f[i][j][k] = (f[i][j][k] + f[i - 1][j][k0]) % mod;
+                }
+                if (j > 0) {
+                    f[i][j][k] = (f[i][j][k] + f[i][j - 1][k0]) % mod;
+                }
             }
         }
     }
-    return ans[m][n][0];
+    return f[m - 1][n - 1][0];
 }
diff --git a/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution2.cpp b/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution2.cpp
deleted file mode 100644
index 0dbc288bb2028..0000000000000
--- a/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution2.cpp	
+++ /dev/null
@@ -1,21 +0,0 @@
-class Solution {
-public:
-    const int mod = 1e9 + 7;
-
-    int numberOfPaths(vector<vector<int>>& grid, int k) {
-        int m = grid.size(), n = grid[0].size();
-        vector<vector<vector<int>>> dp(m, vector<vector<int>>(n, vector<int>(k)));
-        dp[0][0][grid[0][0] % k] = 1;
-        for (int i = 0; i < m; ++i) {
-            for (int j = 0; j < n; ++j) {
-                for (int s = 0; s < k; ++s) {
-                    int t = ((s - grid[i][j] % k) + k) % k;
-                    if (i) dp[i][j][s] += dp[i - 1][j][t];
-                    if (j) dp[i][j][s] += dp[i][j - 1][t];
-                    dp[i][j][s] %= mod;
-                }
-            }
-        }
-        return dp[m - 1][n - 1][0];
-    }
-};
\ No newline at end of file
diff --git a/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution2.go b/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution2.go
deleted file mode 100644
index bce9d55db7107..0000000000000
--- a/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution2.go	
+++ /dev/null
@@ -1,27 +0,0 @@
-func numberOfPaths(grid [][]int, k int) int {
-	m, n := len(grid), len(grid[0])
-	var mod int = 1e9 + 7
-	dp := make([][][]int, m)
-	for i := range dp {
-		dp[i] = make([][]int, n)
-		for j := range dp[i] {
-			dp[i][j] = make([]int, k)
-		}
-	}
-	dp[0][0][grid[0][0]%k] = 1
-	for i := 0; i < m; i++ {
-		for j := 0; j < n; j++ {
-			for s := 0; s < k; s++ {
-				t := ((s - grid[i][j]%k) + k) % k
-				if i > 0 {
-					dp[i][j][s] += dp[i-1][j][t]
-				}
-				if j > 0 {
-					dp[i][j][s] += dp[i][j-1][t]
-				}
-				dp[i][j][s] %= mod
-			}
-		}
-	}
-	return dp[m-1][n-1][0]
-}
\ No newline at end of file
diff --git a/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution2.java b/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution2.java
deleted file mode 100644
index a914f76e5cb4e..0000000000000
--- a/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution2.java	
+++ /dev/null
@@ -1,24 +0,0 @@
-class Solution {
-    private static final int MOD = (int) 1e9 + 7;
-
-    public int numberOfPaths(int[][] grid, int k) {
-        int m = grid.length, n = grid[0].length;
-        int[][][] dp = new int[m][n][k];
-        dp[0][0][grid[0][0] % k] = 1;
-        for (int i = 0; i < m; ++i) {
-            for (int j = 0; j < n; ++j) {
-                for (int s = 0; s < k; ++s) {
-                    int t = ((s - grid[i][j] % k) + k) % k;
-                    if (i > 0) {
-                        dp[i][j][s] += dp[i - 1][j][t];
-                    }
-                    if (j > 0) {
-                        dp[i][j][s] += dp[i][j - 1][t];
-                    }
-                    dp[i][j][s] %= MOD;
-                }
-            }
-        }
-        return dp[m - 1][n - 1][0];
-    }
-}
\ No newline at end of file
diff --git a/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution2.py b/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution2.py
deleted file mode 100644
index 9efd47563808a..0000000000000
--- a/solution/2400-2499/2435.Paths in Matrix Whose Sum Is Divisible by K/Solution2.py	
+++ /dev/null
@@ -1,16 +0,0 @@
-class Solution:
-    def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
-        m, n = len(grid), len(grid[0])
-        dp = [[[0] * k for _ in range(n)] for _ in range(m)]
-        dp[0][0][grid[0][0] % k] = 1
-        mod = 10**9 + 7
-        for i in range(m):
-            for j in range(n):
-                for s in range(k):
-                    t = ((s - grid[i][j] % k) + k) % k
-                    if i:
-                        dp[i][j][s] += dp[i - 1][j][t]
-                    if j:
-                        dp[i][j][s] += dp[i][j - 1][t]
-                    dp[i][j][s] %= mod
-        return dp[-1][-1][0]