+ problem 2435

Author: fruit-in

Problemset/2435-Paths in Matrix Whose Sum Is Divisible by K/README.md

@@ -0,0 +1,71 @@
+# 2435. Paths in Matrix Whose Sum Is Divisible by K
+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** <code>10<sup>9</sup> + 7</code>.
+
+#### Example 1:
+![](https://assets.leetcode.com/uploads/2022/08/13/image-20220813183124-1.png)
+<pre>
+<strong>Input:</strong> grid = [[5,2,4],[3,0,5],[0,7,2]], k = 3
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> There are two paths where the sum of the elements on the path is divisible by k.
+The first path highlighted in red has a sum of 5 + 2 + 4 + 5 + 2 = 18 which is divisible by 3.
+The second path highlighted in blue has a sum of 5 + 3 + 0 + 5 + 2 = 15 which is divisible by 3.
+</pre>
+
+#### Example 2:
+![](https://assets.leetcode.com/uploads/2022/08/17/image-20220817112930-3.png)
+<pre>
+<strong>Input:</strong> grid = [[0,0]], k = 5
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> The path highlighted in red has a sum of 0 + 0 = 0 which is divisible by 5.
+</pre>
+
+#### Example 3:
+![](https://assets.leetcode.com/uploads/2022/08/12/image-20220812224605-3.png)
+<pre>
+<strong>Input:</strong> grid = [[7,3,4,9],[2,3,6,2],[2,3,7,0]], k = 1
+<strong>Output:</strong> 10
+<strong>Explanation:</strong> Every integer is divisible by 1 so the sum of the elements on every possible path is divisible by k.
+</pre>
+
+#### Constraints:
+* `m == grid.length`
+* `n == grid[i].length`
+* <code>1 <= m, n <= 5 * 10<sup>4</sup></code>
+* <code>1 <= m * n <= 5 * 10<sup>4</sup></code>
+* `0 <= grid[i][j] <= 100`
+* `1 <= k <= 50`
+
+## Solutions (Rust)
+
+### 1. Solution
+```Rust
+use std::collections::VecDeque;
+
+impl Solution {
+    pub fn number_of_paths(grid: Vec<Vec<i32>>, k: i32) -> i32 {
+        let k = k as usize;
+        let m = grid.len();
+        let n = grid[0].len();
+        let mut prev_row_mod = vec![VecDeque::from(vec![0; k]); n];
+        prev_row_mod[0][0] = 1;
+
+        for r in 0..m {
+            let mut row_mod = prev_row_mod.clone();
+            row_mod[0].rotate_right(grid[r][0] as usize % k);
+
+            for c in 1..n {
+                for i in 0..k {
+                    row_mod[c][i] = (row_mod[c][i] + row_mod[c - 1][i]) % 1_000_000_007;
+                }
+                row_mod[c].rotate_right(grid[r][c] as usize % k);
+            }
+
+            prev_row_mod = row_mod;
+        }
+
+        prev_row_mod[n - 1][0]
+    }
+}
+```

Problemset/2435-Paths in Matrix Whose Sum Is Divisible by K/README_CN.md

@@ -0,0 +1,71 @@
+# 2435. 矩阵中和能被 K 整除的路径
+给你一个下标从 **0** 开始的 `m x n` 整数矩阵 `grid` 和一个整数 `k` 。你从起点 `(0, 0)` 出发，每一步只能往 **下** 或者往 **右** ，你想要到达终点 `(m - 1, n - 1)` 。
+
+请你返回路径和能被 `k` 整除的路径数目，由于答案可能很大，返回答案对 <code>10<sup>9</sup> + 7</code> **取余** 的结果。
+
+#### 示例 1:
+![](https://assets.leetcode.com/uploads/2022/08/13/image-20220813183124-1.png)
+<pre>
+<strong>输入:</strong> grid = [[5,2,4],[3,0,5],[0,7,2]], k = 3
+<strong>输出:</strong> 2
+<strong>解释:</strong> 有两条路径满足路径上元素的和能被 k 整除。
+第一条路径为上图中用红色标注的路径，和为 5 + 2 + 4 + 5 + 2 = 18 ，能被 3 整除。
+第二条路径为上图中用蓝色标注的路径，和为 5 + 3 + 0 + 5 + 2 = 15 ，能被 3 整除。
+</pre>
+
+#### 示例 2:
+![](https://assets.leetcode.com/uploads/2022/08/17/image-20220817112930-3.png)
+<pre>
+<strong>输入:</strong> grid = [[0,0]], k = 5
+<strong>输出:</strong> 1
+<strong>解释:</strong> 红色标注的路径和为 0 + 0 = 0 ，能被 5 整除。
+</pre>
+
+#### 示例 3:
+![](https://assets.leetcode.com/uploads/2022/08/12/image-20220812224605-3.png)
+<pre>
+<strong>输入:</strong> grid = [[7,3,4,9],[2,3,6,2],[2,3,7,0]], k = 1
+<strong>输出:</strong> 10
+<strong>解释:</strong> 每个数字都能被 1 整除，所以每一条路径的和都能被 k 整除。
+</pre>
+
+#### 提示:
+* `m == grid.length`
+* `n == grid[i].length`
+* <code>1 <= m, n <= 5 * 10<sup>4</sup></code>
+* <code>1 <= m * n <= 5 * 10<sup>4</sup></code>
+* `0 <= grid[i][j] <= 100`
+* `1 <= k <= 50`
+
+## 题解 (Rust)
+
+### 1. 题解
+```Rust
+use std::collections::VecDeque;
+
+impl Solution {
+    pub fn number_of_paths(grid: Vec<Vec<i32>>, k: i32) -> i32 {
+        let k = k as usize;
+        let m = grid.len();
+        let n = grid[0].len();
+        let mut prev_row_mod = vec![VecDeque::from(vec![0; k]); n];
+        prev_row_mod[0][0] = 1;
+
+        for r in 0..m {
+            let mut row_mod = prev_row_mod.clone();
+            row_mod[0].rotate_right(grid[r][0] as usize % k);
+
+            for c in 1..n {
+                for i in 0..k {
+                    row_mod[c][i] = (row_mod[c][i] + row_mod[c - 1][i]) % 1_000_000_007;
+                }
+                row_mod[c].rotate_right(grid[r][c] as usize % k);
+            }
+
+            prev_row_mod = row_mod;
+        }
+
+        prev_row_mod[n - 1][0]
+    }
+}
+```

Problemset/2435-Paths in Matrix Whose Sum Is Divisible by K/Solution.rs

@@ -0,0 +1,27 @@
+use std::collections::VecDeque;
+
+impl Solution {
+    pub fn number_of_paths(grid: Vec<Vec<i32>>, k: i32) -> i32 {
+        let k = k as usize;
+        let m = grid.len();
+        let n = grid[0].len();
+        let mut prev_row_mod = vec![VecDeque::from(vec![0; k]); n];
+        prev_row_mod[0][0] = 1;
+
+        for r in 0..m {
+            let mut row_mod = prev_row_mod.clone();
+            row_mod[0].rotate_right(grid[r][0] as usize % k);
+
+            for c in 1..n {
+                for i in 0..k {
+                    row_mod[c][i] = (row_mod[c][i] + row_mod[c - 1][i]) % 1_000_000_007;
+                }
+                row_mod[c].rotate_right(grid[r][c] as usize % k);
+            }
+
+            prev_row_mod = row_mod;
+        }
+
+        prev_row_mod[n - 1][0]
+    }
+}

README.md

@@ -1451,6 +1451,7 @@
 [2432][2432l]|[The Employee That Worked on the Longest Task][2432]                                  |![rs]
 [2433][2433l]|[Find The Original Array of Prefix Xor][2433]                                         |![rs]
 [2434][2434l]|[Using a Robot to Print the Lexicographically Smallest String][2434]                  |![rs]
+[2435][2435l]|[Paths in Matrix Whose Sum Is Divisible by K][2435]                                   |![rs]
 [2437][2437l]|[Number of Valid Clock Times][2437]                                                   |![py]
 [2438][2438l]|[Range Product Queries of Powers][2438]                                               |![rs]
 [2439][2439l]|[Minimize Maximum of Array][2439]                                                     |![rs]
@@ -2981,6 +2982,7 @@
 [2432]:Problemset/2432-The%20Employee%20That%20Worked%20on%20the%20Longest%20Task/README.md#2432-the-employee-that-worked-on-the-longest-task
 [2433]:Problemset/2433-Find%20The%20Original%20Array%20of%20Prefix%20Xor/README.md#2433-find-the-original-array-of-prefix-xor
 [2434]:Problemset/2434-Using%20a%20Robot%20to%20Print%20the%20Lexicographically%20Smallest%20String/README.md#2434-using-a-robot-to-print-the-lexicographically-smallest-string
+[2435]:Problemset/2435-Paths%20in%20Matrix%20Whose%20Sum%20Is%20Divisible%20by%20K/README.md#2435-paths-in-matrix-whose-sum-is-divisible-by-k
 [2437]:Problemset/2437-Number%20of%20Valid%20Clock%20Times/README.md#2437-number-of-valid-clock-times
 [2438]:Problemset/2438-Range%20Product%20Queries%20of%20Powers/README.md#2438-range-product-queries-of-powers
 [2439]:Problemset/2439-Minimize%20Maximum%20of%20Array/README.md#2439-minimize-maximum-of-array
@@ -4510,6 +4512,7 @@
 [2432l]:https://leetcode.com/problems/the-employee-that-worked-on-the-longest-task/
 [2433l]:https://leetcode.com/problems/find-the-original-array-of-prefix-xor/
 [2434l]:https://leetcode.com/problems/using-a-robot-to-print-the-lexicographically-smallest-string/
+[2435l]:https://leetcode.com/problems/paths-in-matrix-whose-sum-is-divisible-by-k/
 [2437l]:https://leetcode.com/problems/number-of-valid-clock-times/
 [2438l]:https://leetcode.com/problems/range-product-queries-of-powers/
 [2439l]:https://leetcode.com/problems/minimize-maximum-of-array/

README_CN.md

@@ -1451,6 +1451,7 @@
 [2432][2432l]|[处理用时最长的那个任务的员工][2432]                      |![rs]
 [2433][2433l]|[找出前缀异或的原始数组][2433]                            |![rs]
 [2434][2434l]|[使用机器人打印字典序最小的字符串][2434]                  |![rs]
+[2435][2435l]|[矩阵中和能被 K 整除的路径][2435]                         |![rs]
 [2437][2437l]|[有效时间的数目][2437]                                    |![py]
 [2438][2438l]|[二的幂数组中查询范围内的乘积][2438]                      |![rs]
 [2439][2439l]|[最小化数组中的最大值][2439]                              |![rs]
@@ -2981,6 +2982,7 @@
 [2432]:Problemset/2432-The%20Employee%20That%20Worked%20on%20the%20Longest%20Task/README_CN.md#2432-处理用时最长的那个任务的员工
 [2433]:Problemset/2433-Find%20The%20Original%20Array%20of%20Prefix%20Xor/README_CN.md#2433-找出前缀异或的原始数组
 [2434]:Problemset/2434-Using%20a%20Robot%20to%20Print%20the%20Lexicographically%20Smallest%20String/README_CN.md#2434-使用机器人打印字典序最小的字符串
+[2435]:Problemset/2435-Paths%20in%20Matrix%20Whose%20Sum%20Is%20Divisible%20by%20K/README_CN.md#2435-矩阵中和能被-k-整除的路径
 [2437]:Problemset/2437-Number%20of%20Valid%20Clock%20Times/README_CN.md#2437-有效时间的数目
 [2438]:Problemset/2438-Range%20Product%20Queries%20of%20Powers/README_CN.md#2438-二的幂数组中查询范围内的乘积
 [2439]:Problemset/2439-Minimize%20Maximum%20of%20Array/README_CN.md#2439-最小化数组中的最大值
@@ -4510,6 +4512,7 @@
 [2432l]:https://leetcode.cn/problems/the-employee-that-worked-on-the-longest-task/
 [2433l]:https://leetcode.cn/problems/find-the-original-array-of-prefix-xor/
 [2434l]:https://leetcode.cn/problems/using-a-robot-to-print-the-lexicographically-smallest-string/
+[2435l]:https://leetcode.cn/problems/paths-in-matrix-whose-sum-is-divisible-by-k/
 [2437l]:https://leetcode.cn/problems/number-of-valid-clock-times/
 [2438l]:https://leetcode.cn/problems/range-product-queries-of-powers/
 [2439l]:https://leetcode.cn/problems/minimize-maximum-of-array/