leetcode 2435 - 技术栈

2435: 矩阵中和能被K整除的路径

返回答案对 109 + 7 取余的结果

复制代码

constexpr int MOD=1'000'000'007;

思路：动态规划------从记忆化搜索到递推

本题需要统计路径和是 k 的倍数的路径数目。

加法原理：如果完成一件事有若干互不重叠、互不干扰的办法，那么总方法数 = 每类办法数之和。

递归边界：dfs(−1,j,s)=dfs(i,−1,s)=0 无法从 (0,0) 到达这些位置。

dfs(0,0,grid[0][0]modk)=1 起点到它自己有一条路径，即原地不动。

递归入口：题目求从起点 (0,0) 走到 (m−1,n−1)，且路径和模 k 为 0 的路径数，即dfs(m−1,n−1,0)

复制代码

vector memo(m, vector(n, vector<int>(k, -1)));

复制代码

auto dfs = [&](this auto&& dfs, int i, int j, int s) -> int

-> int 是 尾置返回类型（trailing return type） 语法，它明确告诉编译器：这个 lambda 调用后的返回值是 int 类型。

复制代码

class Solution {
public:
    int numberOfPaths(vector<vector<int>>& grid, int k) {
        constexpr int MOD=1'000'000'007;
        int m=grid.size(),n=grid[0].size();
        vector memo(m,vector(n,vector<int>(k,-1)));  //初始化为-1，表示未遇到过

        auto dfs=[&](this auto&& dfs,int i,int j,int s)->int{
            if(i<0 || j<0) return 0; //出界
            int pre_s=((s-grid[i][j])%k+k)%k;
            if(i==0 && j==0){
                return pre_s==0; //是否能回到起点
            }
            int &res=memo[i][j][s];  //引用
            if(res!=-1) return res; //遇到过
            return res=(dfs(i-1,j,pre_s)+dfs(i,j-1,pre_s))%MOD;
        };

        return dfs(m-1,n-1,0);
    }
};

进一步，1:1 翻译成递推。

递归边界：

dfs(−1,0,0)=1。为方便翻译成递推，把 (−1,0) 视作一个合法的位置。从终点 (m−1,n−1) 走到 (−1,0) 时，如果路径和 s 是 k 的倍数，则找到了一条合法路径。
dfs(−1,j,s)=dfs(i,−1,s)=0。除了 (−1,0)，其余出界位置视作非法。

也可以把 f[0][1] 初始化成 1，这样我们无需单独计算 f[1][1]。从 dfs 的角度理解，就是++把 (−1,0) 当作起点，且第一步只能往下走。++

注：如果不写 f[0][1]=1，那么需要在代码中特判 i=j=0 的情况，因为 f[1][1] 属于初始值，不能用状态转移方程计算。但是，如果把初始值改成 f[0][1]=1（或者 f[1][0]=1），就无需特判 i=j=0 的情况了，f[1][1] 也可以用状态转移方程计算。

复制代码

class Solution {
public:
    int numberOfPaths(vector<vector<int>>& grid, int k) {
        constexpr int MOD=1'000'000'007;
        int m=grid.size(),n=grid[0].size();
        vector f(m+1,vector(n+1,vector<int>(k)));
        f[0][1][0]=1;  //把 (−1,0) 当作起点，且第一步只能往下走
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                for(int s=0;s<k;s++){
                    int preS=((s-grid[i][j])%k+k)%k;
                    f[i+1][j+1][s]=(f[i][j+1][preS]+f[i+1][j][preS])%MOD;
                }
            }
        }

        return f[m][n][0];
    }
};