第九章 动态规划part12

最新推荐文章于 2024-07-25 23:26:35 发布
最新推荐文章于 2024-07-25 23:26:35 发布
阅读量368 收藏 4
点赞数 3
分类专栏： 代码随想录 文章标签： 动态规划 算法 数据结构 c++ leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a781333978/article/details/140647990
版权

不同的子序列

题目描述

给你两个字符串 s 和 t ，统计并返回在 s 的 子序列 中 t 出现的个数，结果需要对 109 + 7 取模。

示例 1：

输入：s = "rabbbit", t = "rabbit"
输出：3
解释：
如下所示, 有 3 种可以从 s 中得到 "rabbit" 的方案。
rabbbit
rabbbit
rabbbit

示例 2：

输入：s = "babgbag", t = "bag"
输出：5
解释：
如下所示, 有 5 种可以从 s 中得到 "bag" 的方案。 
babgbag
babgbag
babgbag
babgbag
babgbag

解题思路

  1. 确定dp数组以及下标的含义

    • dp[i][j] 表示在 s 的前 i 个字符中，t 的前 j 个字符出现的次数。

  2. 确定递推公式

    • 如果 s[i-1] == t[j-1]，递推公式：dp[i][j] = dp[i-1][j-1] + dp[i-1][j]

      • dp[i-1][j-1] 表示：在 s 的前 i-1 个字符中，t 的前 j-1 个字符出现的次数。因为 s[i-1] 和 t[j-1] 相等，所以可以把这对匹配的字符加上，形成新的匹配。
      • dp[i-1][j] 表示：在 s 的前 i-1 个字符中，t 的前 j 个字符出现的次数。这里表示跳过当前的 s[i-1]，但仍然保留前面已匹配的子序列次数。

    • 如果 s[i-1] ！= t[j-1]，递推公式：dp[i][j] = dp[i-1][j]

      • 由于 s[i-1] 和 t[j-1] 不相等，所以不能通过这两个字符形成新的匹配，因此只能跳过 s[i-1]，保留 s 的前 i-1 个字符中 t 的前 j 个字符的匹配次数。

  3. dp数组初始化

    • dp[i][0]（表示在s的前i个字符中，空字符串出现的次数）都应该初始化为1，dp[0][j]（表示在空字符串中，t的前j个字符出现的次数）除了dp[0][0] = 1外，其他都应该初始化为0。

  4. 确定遍历顺序

    • 对于dp[i][j]，其值与dp[i-1][j]、dp[i-1][j-1]有关，因此需要保证dp[i-1][j]、dp[i-1][j-1]在dp[i][j]之前被计算。所以，遍历顺序应该是从左到右，逐行进行。

  5. 举例推导dp数组

    • 以s：“baegg”，t："bag"为例，手动推导dp数组状态如下：

      image

代码实现

测试地址：https://leetcode.cn/problems/distinct-subsequences/

class Solution {
public:
    int numDistinct(string s, string t) {
        // 创建一个二维DP数组，dp[i][j]表示在s的前i个字符中，t的前j个字符出现的次数
        vector<vector<uint64_t>> dp(s.size() + 1, vector<uint64_t>(t.size() + 1));
  
        // 初始化dp数组的第一列，表示在s的前i个字符中，空字符串出现的次数，显然都为1
        for (int i = 0; i <= s.size(); i++) dp[i][0] = 1;
  
        // 初始化dp数组的第一行，除了dp[0][0]为1，其他dp[0][j]表示在空字符串中，t的前j个字符出现的次数，显然都为0
        for (int j = 1; j <= t.size(); j++) dp[0][j] = 0;
  
        // 遍历字符串s和t
        for (int i = 1; i <= s.size(); i++) {
            for (int j = 1; j <= t.size(); j++) {
                // 如果当前字符相等，那么dp[i][j]应该是dp[i - 1][j - 1]（选择当前字符）和dp[i - 1][j]（不选择当前字符）的和
                if (s[i-1] == t[j-1]) {
                    dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
                }
                // 如果当前字符不相等，那么dp[i][j]应该等于dp[i - 1][j]
                else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
  
        // 返回在s中，t出现的次数
        return dp[s.size()][t.size()];
    }
};

两个字符串的删除操作

题目描述

给定两个单词 word1 和 word2 ，返回使得 word1 和 word2 相同所需的最小步数。

每步 可以删除任意一个字符串中的一个字符。

示例 1：

输入: word1 = "sea", word2 = "eat"
输出: 2
解释: 第一步将 "sea" 变为 "ea" ，第二步将 "eat "变为 "ea"

示例 2:

输入：word1 = "leetcode", word2 = "etco"
输出：4

解题思路

思路一

  1. 确定dp数组以及下标的含义

    • dp[i][j] 表示将 word1 的前 i 个字符转换为 word2 的前 j 个字符所需的最小操作数。

  2. 确定递推公式

    • 如果 word1[i - 1] == word2[j - 1]，递推公式为： dp[i][j] = dp[i - 1][j - 1]，因为当前字符相同，不需要额外操作。

    • 如果 word1[i - 1] != word2[j - 1]，则需要考虑三种操作：

      • 删除 word1[i - 1]：dp[i - 1][j] + 1
      • 插入 word2[j - 1]：dp[i][j - 1] + 1
      • 替换 word1[i - 1] 为 word2[j - 1]或是两个字符串同时删除当前元素：dp[i - 1][j - 1] + 2（因为替换和删除都需要两次操作：删除和插入）
      • 取这三种操作的最小值，最终的递推公式为：dp[i][j] = min(dp[i - 1][j] + 1, min(dp[i][j - 1] + 1, dp[i - 1][j - 1]

  3. dp数组初始化

    • dp[i][0] 表示将 word1 的前 i 个字符转换为空字符串所需的操作数，即删除 i 次，所以 dp[i][0] = i。

    • dp[0][j] 表示将 word2 的前j个字符转换为空字符串所需的操作数，即删除j次，所以 dp[0][j] = j。

  4. 确定遍历顺序

    • 从左到右，从上到下遍历 dp 数组，确保在计算 dp[i][j] 时，dp[i - 1][j]、dp[i][j - 1] 和 dp[i - 1][j - 1] 已经计算完毕。

  5. 举例推导dp数组

    • 以word1:“sea”，word2:"eat"为例，手动推导dp数组状态图如下：

      image

思路二

如果两个字符串能够分别通过删除一定的元素得到相同的子字符串，那么说明这个子字符串属于两个字符串的最长公共子序列，因此要想得到最少的操作数，可以通过这么一个等式：word1.size() + word2.size() - 2 * LCS长度来得到。

代码实现

测试地址：https://leetcode.cn/problems/delete-operation-for-two-strings/

思路一代码如下：

class Solution {
public:
    int minDistance(string word1, string word2) {
        vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1, 0));
   
        // 初始化第一行和第一列
        for (int i = 0; i <= word1.size(); i++) {
            // dp[i][0] 表示将 word1 的前 i 个字符转换为空字符串所需的操作数，即删除 i 次
            dp[i][0] = i;
        }
        for (int j = 1; j <= word2.size(); j++) {
            // dp[0][j] 表示将 word2 的前j个字符转换为空字符串所需的操作数，即删除j次
            dp[0][j] = j;
        }
  
        // 从左到右，从上到下遍历
        for (int i = 1; i <= word1.size(); i++) {
            for (int j = 1; j <= word2.size(); j++) {
                if (word1[i - 1] == word2[j - 1]) {
                    // 如果当前字符相同，则不需要额外操作
                    dp[i][j] = dp[i - 1][j - 1];
                } else {
                    // 如果当前字符不同，考虑三种操作：删除、插入、替换
                    // 删除：dp[i - 1][j] + 1
                    // 插入：dp[i][j - 1] + 1
                    // 替换：dp[i - 1][j - 1] + 2（因为替换需要两次操作：删除和插入）
                    dp[i][j] = min(dp[i - 1][j] + 1, min(dp[i][j - 1] + 1, dp[i - 1][j - 1] + 2));
                }
            }
        }
    
        // 返回将 word1 转换为 word2 所需的最小操作数
        return dp[word1.size()][word2.size()];
    }
};

思路二代码如下：

class Solution {
public:
    int minDistance(string word1, string word2) {
        vector<vector<int>> dp(word1.size() + 1,
                               vector<int>(word2.size() + 1, 0));
        // 构建 dp 数组
        for (int i = 1; i <= word1.size(); i++) {
            for (int j = 1; j <= word2.size(); j++) {
                // 如果字符相同，则在前一个基础上加一
                // 这里实际上寻找的是最长公共子序列的长度
                if (word1[i - 1] == word2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    // 如果字符不同，取上方和左方的较大值
                    // 同样是为了求最长公共子序列的长度
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        // 根据最长公共子序列的长度计算最少操作次数
        // 整体长度减去两倍的公共部分长度
        return (word1.size() + word2.size()) -
               2 * dp[word1.size()][word2.size()];
    }
};

编辑距离

题目描述

给你两个单词 word1 和 word2， 请返回将 ​word1​ 转换成 ​word2​ 所使用的最少操作数 。

你可以对一个单词进行如下三种操作：

  • 插入一个字符
  • 删除一个字符
  • 替换一个字符

示例 1：

输入：word1 = "horse", word2 = "ros"
输出：3
解释：
horse -> rorse (将 'h' 替换为 'r')
rorse -> rose (删除 'r')
rose -> ros (删除 'e')

示例 2：

输入：word1 = "intention", word2 = "execution"
输出：5
解释：
intention -> inention (删除 't')
inention -> enention (将 'i' 替换为 'e')
enention -> exention (将 'n' 替换为 'x')
exention -> exection (将 'n' 替换为 'c')
exection -> execution (插入 'u')

解题思路

  1. 确定dp数组以及下标的含义

    • dp[i][j]：表示word1的前i个字符转换成word2的前j个字符所使用的最少操作数。

  2. 确定递推公式

    1. 当前字符相等时：

      • 如果word1的第i个字符和word2的第j个字符相同，那么它们互相匹配不需要任何操作，所以当前位置的操作数与word1的前i-1个字符和word2的前j-1个字符所需操作数相同。
      • 因此，递推公式是：dp[i][j] = dp[i - 1][j - 1]

    2. 当前字符不相等时：

      • 如果word1的第i个字符和word2的第j个字符不同，则考虑三种操作：

        • 插入操作：我们可以在word1的第i个字符后面插入一个与word2的第j个字符相同的字符，这样word2的第j字符就被匹配了。此时，我们需要看word1的前i个字符转换成word2的前j-1个字符需要的最少操作数，加上这一次的插入操作，即dp[i][j-1] + 1。
        • 删除操作：我们可以删除word1的第i个字符，然后再看word1的前i-1个字符转换成word2的前j个字符需要的最少操作数，加上这一次的删除操作，即dp[i-1][j] + 1。
        • 替换操作：我们可以将word1的第i个字符替换为word2的第j个字符，这样两个字符就被匹配了。此时，我们需要看word1的前i-1个字符转换成word2的前j-1个字符需要的最少操作数，加上这一次的替换操作，即dp[i-1][j-1] + 1。

      • 在这三种情况中，我们选择操作次数最少的一种，故递推公式是：dp[i][j] = min(dp[i-1][j] + 1, dp[i][j-1] + 1, dp[i-1][j-1] + 1)

  3. dp数组初始化

    • dp[i][0]，即word1的前i个字符转换成空字符串所需要的操作数，即删除操作，所以dp[i][0] = i。
    • dp[0][j]，即空字符串转换成word2的前j个字符所需要的操作数，即插入操作，所以dp[0][j] = j。

  4. 确定遍历顺序

    • 由于dp[i][j]的计算依赖于dp[i - 1][j]（上方）、dp[i][j - 1]（左方）和dp[i - 1][j - 1]（左上方），我们需要从左到右、从上到下的顺序填充dp数组。
    • 首先，初始化第一行和第一列，然后开始遍历填充剩下的dp数组。

  5. 举例推导dp数组

    • 以示例1为例，输入：word1 = "horse", word2 = "ros"为例，手动推导dp矩阵状态图如下：

      image

代码实现

测试地址：https://leetcode.cn/problems/edit-distance/

class Solution {
public:
    int minDistance(string word1, string word2) {
        // 初始化二维 dp 数组
        vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1, 0));

        // dp[i][0] 表示 word1 的前 i 个字符转换成空字符串所需要的操作数，即删除操作
        for (int i = 0; i <= word1.size(); i++) {
            dp[i][0] = i;
        }

        // dp[0][j] 表示空字符串转换成 word2 的前 j 个字符所需要的操作数，即插入操作
        for (int j = 1; j <= word2.size(); j++) {
            dp[0][j] = j;
        }

        // 遍历 word1 和 word2，计算 dp 数组的值
        for (int i = 1; i <= word1.size(); i++) {
            for (int j = 1; j <= word2.size(); j++) {
                // 当 word1 的第 i 个字符和 word2 的第 j 个字符相同，dp[i][j] 等于左上角的值
                if (word1[i - 1] == word2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1];
                }
                // 当 word1 的第 i 个字符和 word2 的第 j 个字符不相同，dp[i][j] 等于左边、上边和左上角的值中的最小值 + 1
                else {
                    dp[i][j] = min(dp[i - 1][j] + 1, min(dp[i][j - 1] + 1, dp[i - 1][j - 1] + 1));
                }
            }
        }
        // 返回 word1 转换成 word2 所需要的最少操作数
        return dp[word1.size()][word2.size()];
    }
};
C1aySec
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
执梗的博客
07-23 1788
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
C语言100道基础拔高题（1）
2303_78660417的博客
07-23 2959
最后按最小值，中间值，最大值的顺序打印即可。解题思路：首先输出由这几个数字所组成的所有三位数，接着再设置条件，使其输出的三位数不重复，下面我们来看下源代码。值得注意的是：所以题目的代码都是作者自行编写，如有更好的思路或者代码的优化，还请指出更正。解题思路：首先找到能整除这个正整数的最小正数，接着重置循环初值，让它继续查找最小正数，最后将得到的所有正数放到一个数组里，最后设置好格式之后循环打印出来。解题思路：首先确定好区间，接着判断是否是素数，素数就是一个大于1的数，除了1和它本身之外，不能被其他数整除。
【算法】退火算法 Simulated Annealing
藓类少女的博客
07-25 1335
退火算法（Simulated Annealing, SA）是一种基于热力学模拟的优化算法，用于求解全局优化问题。它通过模拟物理退火过程来寻找全局最优解。
2024秋招算法
weixin_43364551的博客
07-22 2193
根据代码随想录和力扣进行算法训练的笔记
算法 —— 暴力枚举
最新发布
fen_0108的博客
07-25 3486
第二看纵向宽发生改变，长重置为1，长为1，宽为2的时候，第一行个数为7个，总共有5 x 7 个，长为2，宽为2的时候 第一行个数为6个，共有5 x 6个……首先是横着的长方形，宽始终为1，长不断发生改变，可以看出长为2的时候，第一行个数为6个，总共有6 x 6个，长为3的时候，总共有6 x 5个……这是一道简单的模拟题，枚举出所有可能情况，不会超过规定时间的，以下附上k
河南萌新联赛2024第（二）场：南阳理工学院
a13997460860的博客
07-25 1385
这场比赛里面出到了很多的题，都是需要很多的时间去写，主要考察到了代码的实现能力，与codeforces里面的题有些差距。codeforces打多了还是有点不习惯的。题挺好的，尤其是H题感觉很考代码实现能力与STL的使用熟练度。多写写这样的题还是对我们很有好处的。只不过前三题都太水了，没有一点难度。
2024.7.24 作业
qq_64434282的博客
07-24 2164
【代码】2024.7.24 作业。
【初阶数据结构篇】单链表的实现（赋源码）
2301_79849925的博客
07-25 1551
​ 链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表主要有两个部分：当前结点要保存的数据和保存下⼀个结点的地址（指针变量）。本篇主要介绍单链表的实现方法。
数据结构：栈
2301_79601095的博客
07-23 1279
主要介绍了栈的基本概念和结构，然后再详细描述了栈的顺序存储实现和链式存储实现的方法和实现代码，最后再对比栈的顺序存储和链式存储的区别。
数据结构和算法入门
weixin_67852890的博客
07-25 1633
链表（Linked List）是一种线性数据结构，由一系列节点（Node）组成。每个节点包含两部分：元素值（Element Value）和指向下一个节点的指针（Pointer）。链表可以分为多种类型，如单向链表、双向链表、循环链表等。元素在存储上并不连续。队列是一种基础且广泛应用的线性数据结构，它模拟了现实生活中的排队现象，遵循“先进先出”（First-In-First-Out, FIFO）原则。
数据结构概述
ADCvbV的博客
07-25 263
​ 栈，队列，数组，链，二叉树，二叉查找树，平衡二叉树，红黑树。1.每种数据结构长什么样子?
背单词工具(C++)
zeyeqianli的博客
07-24 3646
【代码】背单词工具(C++)
c＋＋初阶知识——string类详解
qq_58761784的博客
07-25 2061
C语言中，字符串是以'\0'结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。
C++的STL简介（一）
2302_81171591的博客
07-23 1411
STL（standarf template libaray-标准模板库）：是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。
C：图案打印
2401_85010100的博客
07-23 1083
空心正方形，空心三角形，X形，沙漏图案打印
C++红黑树
杀意感知的博客
07-25 730
AVL树：严格平衡（左右子树高度差不超过 1），所以 AVL 树的查找、插入、删除效率高：O(logN)，但在插入和删除节点后，要维持树的平衡状态，做的旋转处理还是很多的。红黑树：近似平衡（控制最长路径不超过最短路径的2倍），变了一种方式来控制树的平衡，相较于 AVL 树而言，没有那么严格。红黑树更多是一种折中的选择，它舍弃平衡二叉树的严格平衡，换取节点插入时尽可能少的调整。因为红黑树的旋转情况少于 AVL 树，使得红黑树整体性能略优于。
C语言典型例题14
2302_77517102的博客
07-25 409
中国在2020年11月1日进行第7次全国人口普查，全国人口为1411778724人，假设年增长率为0.5%，计算到2050年有多少人口？
项目实战——外挂开发（30小时精通C++和外挂实战）
qq_44870829的博客
07-25 1920
全局指针变量g_data的地址值是固定死的，它存储的是gamedata的地址，我们可以通过这个找到g_data的存储空间里存储的地址（new出来的是变化的），就能找到gamedata的存储空间，找到了gamedata的存储空间就能找到成员变量sun指针（跳过前面4个字节地址）变量的存储空间，知道它里面存储的值（阳光存储空间的地址值）就能找到阳光存储空间，就能找到阳光存储空间中的阳光值value（跳过前面8个字节地址）。这样就达到了秒杀僵尸的功能了，我们发现第一个字节都是一样的，我们改后面三个字节就可以了。
C语言100基础拔高题（3）
2303_78660417的博客
07-23 989
解题思路：通过switch语句来判断第一个字母，如果遇到字母相同的，在case语句中继续使用if语句来进行第二个字母的判断。解题思路：首先通过判断得出它是几位数，接着有几位数就输出几次，每次都输出最右边的数字。解题思路：我们这里假设它是按照从小到大的顺序进行排序，首先判断它是否大于最右边的数，如果小于，则考虑插入到中间的情况。解题思路：质数又称素数，有无限个。解题思路：通过设置一个新数组，来接收除了要删除字母以外的其他字母。解题思路：得到输入的5位数的个位，十位，千位，万位上的数字，再对其进行比较。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值