6203. 矩阵中和能被 K 整除的路径（每日一难phase2--day29）

6203. 矩阵中和能被 K 整除的路径

给你一个下标从 0 开始的 m x n 整数矩阵 grid 和一个整数 k 。你从起点 (0, 0) 出发，每一步只能往 下 或者往 右 ，你想要到达终点 (m - 1, n - 1) 。

请你返回路径和能被 k 整除的路径数目，由于答案可能很大，返回答案对 109 + 7 取余 的结果。

示例 1：

输入：grid = [[5,2,4],[3,0,5],[0,7,2]], k = 3
输出：2
解释：有两条路径满足路径上元素的和能被 k整除。
第一条路径为上图中用红色标注的路径，和为 5 + 2 + 4 + 5 + 2 = 18 ，能被 3 整除。
第二条路径为上图中用蓝色标注的路径，和为 5 + 3 + 0 + 5 + 2 = 15 ，能被 3 整除。

示例 2：

输入：grid = [[0,0]], k = 5
输出：1
解释：红色标注的路径和为 0 + 0 = 0 ，能被 5 整除。

示例 3：

输入：grid = [[7,3,4,9],[2,3,6,2],[2,3,7,0]], k = 1
输出：10
解释：每个数字都能被 1 整除，所以每一条路径的和都能被 k 整除。

提示：

m == grid.length
n == grid[i].length
1 <= m, n <= 5 * 1e4
1 <= m * n<= 5 * 1e4
0 <= grid[i][j] <= 100
1 <= k <= 50

解析：

• 方法1暴力递归
• 方法2，记忆化搜索
• 方法3，动态规划（从左上到右下，从右下到左上）
• 动态规划：选择从右下到左上，f[x][y][l]表示，第x行，y列提供余数为 l 的路径个数；
• 状态转移 ： f[x][y][tmp] = ((long long)f[x+1][y][l]+f[x][y+1][l])%mod;
• 左方和下方，提供余数为l时，第x行，y列余数为 tmp (tmp=(l+grid[x][y])%k) 时的路径个数.
• f[0][0][0]表示第0行，0列余数为 0时，路径个数（也就是路径总和%k为0）。

代码：

/*
// 记忆化搜索，数组运用不当过不了
class Solution {
    int mod=1e9+7;
public:
    int m,n;
    int dfs(vector<vector<int>>& grid, int k,int x,int y,int sum,vector<vector<vector<int>>>& f){
        if(f[x][y][sum])
            return f[x][y][sum];
        if(x==m-1&&y==n-1){
            if((sum+grid[x][y])%k==0)
                return 1;
            else 
                return 0;
        }

        int tmp=sum;
        sum+=grid[x][y];
        sum%=k;
        int a=0, b=0;
        if(x+1<m)
            a = dfs(grid,k,x+1,y,sum,f);
        if(y+1<n)
            b = dfs(grid,k,x,y+1,sum,f);
        // cout<<a<<":"<<b<<endl;
        f[x][y][tmp] = ((long long)a+b)%mod;
        return f[x][y][tmp];
    }
    int numberOfPaths(vector<vector<int>>& grid, int k) {
        m=grid.size(),n=grid[0].size();
        vector<vector<vector<int>>> f(m+1,vector<vector<int>>(n+1,vector<int>(k+1,0)));
        return dfs(grid,k,0,0,0,f);
    }
};
*/

class Solution {
    int mod=1e9+7;
public:
    int numberOfPaths(vector<vector<int>>& grid, int k) {
        int m=grid.size(),n=grid[0].size();
        int f[m+1][n+1][k+1];
        memset(f,0,sizeof(f));

        // f[x][y][l]表示当前层grid[x][y]提供数字为l时，可以提供的路径最大数
        f[m-1][n-1][grid[m-1][n-1]%k]=1;
        for(int x=m-1;x>=0;x--){
            for(int y=n-1;y>=0;y--){
                // 遍历右侧，下侧可以提供余数l
                for(int l=0;l<k;l++){
                	// 最后一个元素只能提供余数为grid[m-1][n-1]%k的路径
                	// 防止赋值被覆盖
                    if(x==m-1&&y==n-1)
                        break;
                    int tmp = grid[x][y]%k;
                    tmp+=l;
                    tmp%=k;
                    // 右侧，下侧可以提供余数l时，加上该数字可以产生的余数为tmp
                    // 如果不考虑余数，当作真实数字更好理解点
                    f[x][y][tmp] = ((long long)f[x+1][y][l]+f[x][y+1][l])%mod;
                }
            }
        }
        return f[0][0][0];
    }
};