「代码随想录算法训练营」第三十九天 | 动态规划 part12

合集 - 「代码随想录算法训练营」(53)

1.「代码随想录算法训练营」第二天 | 数组 part22024-07-042.「代码随想录算法训练营」第三天 | 链表 part12024-07-053.「代码随想录算法训练营」第四天 | 链表 part22024-07-064.「代码随想录算法训练营」第一天（补） | 数组 part12024-07-075.「代码随想录算法训练营」第五天 | 哈希表 part12024-07-086.「代码随想录算法训练营」第六天 | 哈希表 part22024-07-097.「代码随想录算法训练营」第七天 | 字符串 part12024-07-108.「代码随想录算法训练营」第八天 | 字符串 part22024-07-119.「代码随想录算法训练营」第九天 | 栈与队列 part12024-07-1210.「代码随想录算法训练营」第十天 | 栈与队列 part22024-07-1311.「代码随想录算法训练营」第十一天 | 二叉树 part12024-07-1512.「代码随想录算法训练营」第十二天 | 二叉树 part22024-07-1613.「代码随想录算法训练营」第十三天 | 二叉树 part32024-07-1714.「代码随想录算法训练营」第十四天 | 二叉树 part42024-07-1815.「代码随想录算法训练营」第十五天 | 二叉树 part52024-07-1916.「代码随想录算法训练营」第十六天 | 二叉树 part62024-07-2017.「代码随想录算法训练营」第十七天 | 二叉树 part72024-07-2218.「代码随想录算法训练营」第十八天 | 二叉树 part82024-07-2319.「代码随想录算法训练营」第十九天 | 回溯算法 part12024-07-2420.「代码随想录算法训练营」第二十天 | 回溯算法 part22024-07-2521.「代码随想录算法训练营」第二十一天 | 回溯算法 part32024-07-2622.「代码随想录算法训练营」第二十二天 | 回溯算法 part42024-07-2723.「代码随想录算法训练营」第二十三天 | 贪心算法 part12024-07-2924.「代码随想录算法训练营」第二十四天 | 贪心算法 part22024-08-0125.「代码随想录算法训练营」第二十五天 | 贪心算法 part32024-08-0126.「代码随想录算法训练营」第二十六天 | 贪心算法 part42024-08-0127.「代码随想录算法训练营」第二十七天 | 贪心算法 part52024-08-0228.「代码随想录算法训练营」第二十八天 | 动态规划 part12024-08-0329.「代码随想录算法训练营」第二十九天 | 动态规划 part22024-08-0530.「代码随想录算法训练营」第三十天 | 动态规划 part32024-08-0631.「代码随想录算法训练营」第三十一天 | 动态规划 part42024-08-0732.「代码随想录算法训练营」第三十二天 | 动态规划 part52024-08-0833.「代码随想录算法训练营」第三十三天 | 动态规划 part62024-08-0934.「代码随想录算法训练营」第三十四天 | 动态规划 part72024-08-1035.「代码随想录算法训练营」第三十五天 | 动态规划 part82024-08-1236.「代码随想录算法训练营」第三十六天 | 动态规划 part92024-08-1337.「代码随想录算法训练营」第三十七天 | 动态规划 part102024-08-1438.「代码随想录算法训练营」第三十八天 | 动态规划 part112024-08-15

39.「代码随想录算法训练营」第三十九天 | 动态规划 part122024-08-16

40.「代码随想录算法训练营」第四十一天 | 单调栈 part12024-08-1941.「代码随想录算法训练营」第四十天 | 动态规划 part132024-08-1742.「代码随想录算法训练营」第四十二天 | 单调栈 part22024-08-2043.「代码随想录算法训练营」第四十三天 | 图论 part12024-08-2144.「代码随想录算法训练营」第四十四天 | 图论 part22024-08-2245.「代码随想录算法训练营」第四十五天 | 图论 part32024-08-2346.「代码随想录算法训练营」第四十六天 | 图论 part42024-08-2647.「代码随想录算法训练营」第四十七天 | 图论 part52024-08-2648.「代码随想录算法训练营」第四十八天 | 图论 part62024-08-2749.「代码随想录算法训练营」第四十九天 | 图论 part72024-08-3050.「代码随想录算法训练营」第五十天 | 图论 part82024-08-3151.「代码随想录算法训练营」第五十一天 | 图论 part92024-09-0152.「代码随想录算法训练营」第五十二天 | 图论 part102024-09-0353.「代码随想录算法训练营」完结！2024-09-03

收起

115. 不同的子序列

题目链接：https://leetcode.cn/problems/distinct-subsequences/
文章讲解：https://programmercarl.com/0115.不同的子序列.html
题目难度：困难
视频讲解：https://www.bilibili.com/video/BV1fG4y1m75Q/
题目状态：看题解

思路：

1. 动态规划数组初始化
   • 创建一个二维动态规划数组 dp，大小为 ((s.size() + 1), (t.size() + 1))。dp[i][j] 表示 s 的前 i 个字符中包含 t 的前 j 个字符的不同子序列的数量。
2. 边界条件设置
   • dp[i][0] = 1：表示任何字符串 s 的前 i 个字符都可以形成空字符串 t 的一种方式（即选择不选）。
   • dp[0][j] = 0（对于 (j > 0)）：表示空字符串 s 无法形成非空字符串 t。
3. 动规数组更新
   • 外层循环遍历 s 的每个字符（从 1 到 s.size()）。
   • 内层循环遍历 t 的每个字符（从 1 到 t.size()）。
   • 如果 s[i-1] 和 t[j-1] 相等：
     • dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]：表示可以选择将这个字符包含在子序列中（加上 dp[i-1][j-1]）或者不包含（加上 dp[i-1][j]）。
   • 如果不相等：
     • dp[i][j] = dp[i - 1][j]：只能选择不包含 s[i-1]。
4. 结果
   • 返回 dp[s.size()][t.size()]，即 s 中包含 t 的不同子序列的数量。

代码：

class Solution {
public:
    int numDistinct(string s, string t) {
        int sLen = s.size(), tLen = t.size();
        vector<vector<uint64_t>> dp(sLen + 1, vector<uint64_t>(tLen + 1));
        for(int i = 0; i < sLen; ++i) dp[i][0] = 1;
        for(int j = 1; j < tLen; ++j) dp[0][j] = 0;
        for(int i = 1; i <= sLen; ++i) {
            for(int j = 1; j <= tLen; ++j) {
                if(s[i - 1] == t[j - 1]) dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
                else dp[i][j] = dp[i - 1][j];
            }
        }
        return dp[sLen][tLen];
    }
};

583. 两个字符串的删除操作

题目链接：https://leetcode.cn/problems/delete-operation-for-two-strings/
文章讲解：https://programmercarl.com/0583.两个字符串的删除操作.html
题目难度：中等
视频讲解：https://www.bilibili.com/video/BV1we4y157wB/
题目状态：看题解

思路：

维护一个二维动规数组dp[i][j]用来表示将word1的前i个字符转换为word2的前j个字符所需的最小操作次数。

初始化dp[i][j]：

• dp[i][0] = i：将word1的前i个字符转换为空字符串需要i次删除操作。
• dp[0][j] = j：将空字符串转换为word2的前j个字符需要j次插入操作。

更新动规数组：
对于每一对i和j，我们考虑以下两种情况：

• 字符匹配（word1[i-1] == word2[j-1]）：
  • 如果当前字符相同，不需要任何操作： dp[i][j] = dp[i - 1][j - 1];
• 字符不匹配（word1[i-1] != word2[j-1]）：
  • 我们可以进行两种操作：
    • 删除一次word1的元素：此时需要dp[i - 1][j] + 1次操作次数。
    • 删除一次word2的元素：此时需要dp[i][j - 1] + 1此操作次数。
  • 取这两种操作的最小值：min(dp[i - 1][j] + 1, dp[i][j - 1] + 1)

代码：

class Solution {
public:
    int minDistance(string word1, string word2) {
        int len1 = word1.size(), len2 = word2.size();
        vector<vector<int>> dp(len1 + 1, vector<int>(len2 + 1));
        for(int i = 0; i <= len1; ++i) dp[i][0] = i;
        for(int j = 0; j <= len2; ++j) dp[0][j] = j;
        for(int i = 1; i <= len1; ++i) {
            for(int j = 1; j <= len2; ++j) {
                if(word1[i - 1] == word2[j - 1]) dp[i][j] = dp[i - 1][j - 1];
                else dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1);
            }
        }
        return dp[len1][len2];
    }
};

72. 编辑距离

题目链接：https://leetcode.cn/problems/edit-distance/
文章讲解：https://programmercarl.com/0072.编辑距离.html
题目难度：中等
视频讲解：https://www.bilibili.com/video/BV1qv4y1q78f/
题目状态：有思路，细节出了问题

思路：

这道题的本质就是在上道题的基础上做了改变，上道题遇到不相等的字符时只需要考虑删除操作，这道题在遇到不相等的字符时需要考虑三种情况：删除、插入、替换。

• 删除：在word1中删除一个字符，也就转化为了word1[i - 2]与word2[j - 1]相比较了，因此dp[i][j] = dp[i - 1][j] + 1。
• 插入：在word1中添加一个字符，其实这个操作得到的最终结果和在word2中删除一个字符的结果是一样的，因此就转化为word1[i - 1]与word2[j - 2]相比较了，因此dp[i][j] = dp[i][j - 1] + 1。
• 替换：替换操作就是在word1[i - 1] != word2[j - 1]的前提下进行一次操作使得word1[i - 1] == word2[j - 1]，因此dp[i][j] = dp[i - 1][j - 1] + 1。

最终取这三个操作的最小值即可。

代码：

class Solution {
public:
    int minDistance(string word1, string word2) {
        int len1 = word1.size(), len2 = word2.size();
        vector<vector<int>> dp(len1 + 1, vector<int>(len2 + 1));
        for(int i = 0; i <= len1; ++i) dp[i][0] = i;
        for(int j = 0; j <= len2; ++j) dp[0][j] = j;
        for(int i = 1; i <= len1; ++i) {
            for(int j = 1; j <= len2; ++j) {
                if(word1[i - 1] == word2[j - 1]) dp[i][j] = dp[i - 1][j - 1];
                else dp[i][j] = min({dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]}) + 1;
            }
        }
        return dp[len1][len2];
    }
};