【七十六】【算法分析与设计】2435. 矩阵中和能被 K 整除的路径,87. 扰乱字符串,三维动态规划

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

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

请你返回路径和能被 k 整除的路径数目，由于答案可能很大，返回答案对 10(9)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 * 10(4)

1 <= m * n <= 5 * 10(4)

0 <= grid[i][j] <= 100

1 <= k <= 50

定义f函数,希望将已知信息扔进去加工出我们希望的结果.

我们希望得到从(0,0)位置开始到右下角路径和对k取余为0的路径数.

可以定义f函数从(i,j)位置开始到右下角路径和对k取余为r的路径数.

因此我们需要得到f(0,0,0)的结果.

我们只走一步,从(i,j)位置开始到右下角路径和对k取余为r的路径数.

走一步的结果是(i+1,j)位置或者(i,j+1)位置,能不能找到两者的等价关系.

可以将(i,j)位置的元素值假设为a,走一步位置到右下角的路径和假设为b.

(a+b)%k=r,等价于(a%k+b%k)%k=r.

a%k范围是[0,k-1],b%k范围是[0,k-1].

a%k+b%k范围是[0,2*k-1].

r的范围是[0,k-1].

因此a%k+b%k=r或者r+k.

b%k=r-a%k或者r+k-a%k

b%k=(r+k-a%k)%k.

因此从(i,j)位置开始到右下角路径和对k取余为r的路径数.等价于走一步开始到右下角路径和对k取余为(r+k-a%k)%k的路径数.

处理边界情况,先把状态转移方程写出来,dp[i][j][r]=dp[i+1][j][(r+k-a%k)%k]+dp[i][j+1][(r+k-a%k)%k].

越界的情况是i或者j.很容易知道越界返回0即可.

思考basecase情况,也就是最基本的可以直接得出答案的情况.

也就是当前位置是右下角位置,此时对k取余为r的路径数只需要判断当前元素对k取余是不是等于r即可.

cpp 复制代码

#include <vector>
using namespace std;

class Solution {
public:
    vector<vector<int>> grid; // 定义一个二维数组用于存储输入的网格
    int k, n, m; // k为路径和需要被整除的数，n和m分别为网格的行数和列数
    vector<vector<vector<int>>> dp; // 定义一个三维动态规划数组，用于存储中间结果
    const int MOD = 1e9 + 7; // 定义一个大数作为模数，以防止结果过大

    // 初始化动态规划数组的辅助函数
    void solveInit() {
        n = grid.size(), m = grid[0].size(); // 更新网格的行数和列数
        dp.clear(); // 清空之前的动态规划数组
        // 重新初始化动态规划数组的大小为n*m*k
        dp.resize(n, vector<vector<int>>(m, vector<int>(k, -1)));
    }

    // 深度优先搜索的递归函数，用于计算满足条件的路径数目
    int dfs(int i, int j, int r) {
        // 如果当前位置超出网格范围，则无法继续移动，返回0
        if (i >= n || j >= m)
            return 0;
        // 如果到达终点，检查路径和是否能被k整除
        if (i == n - 1 && j == m - 1)
            return (grid[i][j] % k == r) ? 1 : 0;
        // 如果当前状态已经在dp数组中计算过，则直接返回结果
        if (dp[i][j][r] != -1)
            return dp[i][j][r];

        int newR = (r + k - (grid[i][j] % k)) % k; // 计算新的路径和对应的余数
        // 递归计算向下移动和向右移动到达终点的路径数目，并取模
        dp[i][j][r] = (dfs(i + 1, j, newR) + dfs(i, j + 1, newR)) % MOD;
        return dp[i][j][r];
    }

    // 主函数，用于计算满足条件的路径数目
    int numberOfPaths(vector<vector<int>>& _grid, int _k) {
        grid = _grid; // 更新输入的网格
        k = _k; // 更新k的值
        solveInit(); // 初始化动态规划数组
        // 从起点(0, 0)开始，路径和的初始余数为0，递归计算路径数目
        return dfs(0, 0, 0);
    }
};

87. 扰乱字符串

使用下面描述的算法可以扰乱字符串 s 得到字符串 t ：

如果字符串的长度为 1 ，算法停止

如果字符串的长度 > 1 ，执行下述步骤：

在一个随机下标处将字符串分割成两个非空的子字符串。即，如果已知字符串 s ，则可以将其分成两个子字符串 x 和 y ，且满足 s = x + y 。

随机决定是要「交换两个子字符串」还是要「保持这两个子字符串的顺序不变」。即，在执行这一步骤之后，s 可能是 s = x + y 或者 s = y + x 。

在 x 和 y 这两个子字符串上继续从步骤 1 开始递归执行此算法。

给你两个 长度相等 的字符串 s1和 s2，判断 s2是否是 s1的扰乱字符串。如果是，返回 true ；否则，返回 false 。

示例 1：

输入： s1 = "great", s2 = "rgeat" 输出： true **解释：**s1 上可能发生的一种情形是： "great" --> "gr/eat" // 在一个随机下标处分割得到两个子字符串 "gr/eat" --> "gr/eat" // 随机决定：「保持这两个子字符串的顺序不变」 "gr/eat" --> "g/r / e/at" // 在子字符串上递归执行此算法。两个子字符串分别在随机下标处进行一轮分割 "g/r / e/at" --> "r/g / e/at" // 随机决定：第一组「交换两个子字符串」，第二组「保持这两个子字符串的顺序不变」 "r/g / e/at" --> "r/g / e/ a/t" // 继续递归执行此算法，将 "at" 分割得到 "a/t" "r/g / e/ a/t" --> "r/g / e/ a/t" // 随机决定：「保持这两个子字符串的顺序不变」算法终止，结果字符串和 s2 相同，都是 "rgeat" 这是一种能够扰乱 s1 得到 s2 的情形，可以认为 s2 是 s1 的扰乱字符串，返回 true

示例 2：

输入： s1 = "abcde", s2 = "caebd" **输出：**false

示例 3：

输入： s1 = "a", s2 = "a" **输出：**true

提示：

s1.length == s2.length

1 <= s1.length <= 30

s1 和 s2 由小写英文字母组成

s1[i,j]区间是否可以转化为s2[x,y]区间.f函数定义.

走一步,枚举所有分割的情况,对于每一种情况考虑交换或者不交换.

cpp 复制代码

class Solution {
public:
    string s1, s2; // 声明两个字符串s1和s2
    int n; // 字符串的长度
    vector<vector<vector<vector<int>>>> dp; // 声明一个四维动态规划数组dp

    // 初始化动态规划数组的辅助函数
    void solveinit() {
        n = s1.size(); // 获取字符串s1的长度
        dp.clear(), // 清空之前的动态规划数组
        dp.resize(n, vector<vector<vector<int>>>(
                         n, vector<vector<int>>(n, vector<int>(n, -1)))); // 初始化dp数组
    }

    // 深度优先搜索的递归函数，用于判断s2是否是s1的扰乱字符串
    bool dfs(int i, int j, int x, int y) {
        // 如果当前状态已经在dp数组中计算过，则直接返回结果
        if (dp[i][j][x][y] != -1)
            return dp[i][j][x][y];
        // 如果子串长度为1，判断对应字符是否相等
        if (i == j) {
            dp[i][j][x][y] = s1[i] == s2[x];
            return s1[i] == s2[x];
        }

        bool flag = false; // 初始化标志位为false
        // 枚举s1的子串分割点
        for (int k = 0; k < j - i; k++) {
            // 情况1：保持s1的子串顺序，判断s2的对应子串是否满足条件
            flag |= (dfs(i, i + k, x, x + k) && dfs(i + k + 1, j, x + k + 1, y));
            // 情况2：交换s1的子串顺序，判断s2的对应子串是否满足条件
            flag |= (dfs(i, i + k, y - k, y) && dfs(i + k + 1, j, x, y - k - 1));
        }
        // 存储当前状态的计算结果
        dp[i][j][x][y] = flag;
        return flag; // 返回当前状态的计算结果
    }

    // 主函数，用于判断s2是否是s1的扰乱字符串
    bool isScramble(string _s1, string _s2) {
        s1 = _s1, s2 = _s2; // 更新输入的两个字符串
        solveinit(); // 初始化动态规划数组
        // 从整个字符串的起始位置开始判断
        return dfs(0, n - 1, 0, n - 1);
    }
};

结尾

最后，感谢您阅读我的文章，希望这些内容能够对您有所启发和帮助。如果您有任何问题或想要分享您的观点，请随时在评论区留言。

同时，不要忘记订阅我的博客以获取更多有趣的内容。在未来的文章中，我将继续探讨这个话题的不同方面，为您呈现更多深度和见解。

谢谢您的支持，期待与您在下一篇文章中再次相遇！