feat: add solutions to lc problem: No.2435

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];
     }
-};
+};

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)
-}
+	return f[m-1][n-1][0]
+}

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;
-    }
-}
+}

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]

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]
+    }
+}

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];
 }