【算法优选】 动态规划之子数组、子串系列——贰

最新推荐文章于 2024-06-12 10:00:23 发布
最新推荐文章于 2024-06-12 10:00:23 发布
阅读量999 收藏 19
点赞数 19
分类专栏： 算法优选 文章标签： 算法 动态规划 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71731682/article/details/138924995
版权

文章目录

🎋前言

动态规划相关题目都可以参考以下五个步骤进行解答：

  1. 状态表示

  2. 状态转移⽅程

  3. 初始化

  4. 填表顺序

  5. 返回值

后面题的解答思路也将按照这五个步骤进行讲解。

🎍乘积为正数的最长子数组长度

🚩题目描述

给你一个整数数组 nums ，请你求出乘积为正数的最长子数组的长度。

一个数组的子数组是由原数组中零个或者更多个连续数字组成的数组。

请你返回乘积为正数的最长子数组长度。

  • 示例 1：
    输入：nums = [1,-2,-3,4]
    输出：4
    解释：数组本身乘积就是正数，值为 24 。
  • 示例 2：
    输入：nums = [0,1,-2,-3,-4]
    输出：3
    解释：最长乘积为正数的子数组为 [1,-2,-3] ，乘积为 6 。
    注意，我们不能把 0 也包括到子数组中，因为这样乘积为 0 ，不是正数。
  • 示例 3：
    输入：nums = [-1,-2,-3,0,1]
    输出：2
    解释：乘积为正数的最长子数组是 [-1,-2] 或者 [-2,-3] 。
class Solution {
    public int getMaxLen(int[] nums) {

    }
}

🚩算法思路

继续效仿「最⼤⼦数组和」中的状态表⽰，尝试解决这个问题。

状态表⽰： dp[i] 表⽰「所有以 i 结尾的⼦数组，乘积为正数的最⻓⼦数组的⻓度」。

思考状态转移：对于 i 位置上的 nums[i] ，我们可以分三种情况讨论：

  1. 如果 nums[i] = 0 ，那么所有以 i 为结尾的⼦数组的乘积都不可能是正数，此时dp[i] = 0 ；
  2. 如果 nums[i] > 0 ，那么直接找到 dp[i - 1] 的值（这⾥请再读⼀遍 dp[i -1] 代表的意义，并且考虑如果 dp[i - 1] 的结值是 0 的话，影不影响结果），然后加⼀即可，此时 dp[i] = dp[i - 1] + 1 ；
  3. 如果 nums[i] < 0 ，这时候你该蛋疼了，因为在现有的条件下，你根本没办法得到此时的最⻓⻓度。因为乘法是存在「负负得正」的，单单靠⼀个 dp[i - 1] ，我们⽆法推导出 dp[i] 的值。但是，如果我们知道「以 i - 1 为结尾的所有⼦数组，乘积为负数的最长⼦数组的⻓度」 neg[i - 1] ，那么此时的 dp[i] 是不是就等于 neg[i - 1] + 1呢？

通过上⾯的芬析，我们可以得出，需要两个 dp 表，才能推导出最终的结果。不仅需要⼀个「乘积为正数的最长子数组」，还需要⼀个「乘积为负数的最长子数组」。

  1. 状态表⽰：

f[i] 表⽰：以 i 结尾的所有⼦数组中，乘积为「正数」的最⻓⼦数组的⻓度；

g[i] 表⽰：以 i 结尾的所有⼦数组中，乘积为「负数」的最⻓⼦数组的⻓度。

  1. 状态转移⽅程：

遍历每⼀个位置的时候，我们要同步更新两个 dp 数组的值。

对于 f[i] ，也就是以 i 为结尾的乘积为「正数」的最⻓⼦数组，根据nums[i] 的值，可以分为三种情况：

  • nums[i] = 0 时，所有以 i 为结尾的⼦数组的乘积都不可能是正数，此时 f[i] =0 ；
  • nums[i] > 0 时，那么直接找到 f[i - 1] 的值（这⾥请再读⼀遍 f[i - 1] 代表
    的意义，并且考虑如果 f[i - 1] 的结值是 0 的话，影不影响结果），然后加⼀即可，此时 f[i] = f[i - 1] + 1 ；
  • nums[i] < 0 时，此时我们要看 g[i - 1] 的值（这⾥请再读⼀遍 g[i - 1] 代
    表的意义。因为负负得正，如果我们知道以 i - 1 为结尾的乘积为负数的最⻓⼦数组的⻓度，加上 1 即可），根据 g[i - 1] 的值，⼜要分两种情况：
    • g[i - 1] = 0 ，说明以 i - 1 为结尾的乘积为负数的最⻓⼦数组是不存在的，⼜因为 nums[i] < 0 ，所以以 i 结尾的乘积为正数的最⻓⼦数组也是不存在的，此时 f[i] = 0 ；
    • g[i - 1] != 0 ，说明以 i - 1 为结尾的乘积为负数的最⻓⼦数组是存在的，⼜因为 nums[i] < 0 ，所以以 i 结尾的乘积为正数的最⻓⼦数组就等于 g[i -1] + 1 ；

综上所述， nums[i] < 0 时， f[i] = g[i - 1] == 0 ? 0 : g[i - 1] +1;

对于 g[i] ，也就是以 i 为结尾的乘积为「负数」的最⻓⼦数组，根据nums[i] 的值，可以分为三种情况：

  • nums[i] = 0 时，所有以 i 为结尾的⼦数组的乘积都不可能是负数，此时g[i] =0 ；
  • nums[i] < 0 时，那么直接找到 f[i - 1] 的值（这⾥请再读⼀遍 f[i - 1] 代表
    的意义，并且考虑如果 f[i - 1] 的结值是 0 的话，影不影响结果），然后加⼀即可（因为正数 * 负数 = 负数），此时 g[i] = f[i - 1] + 1 ；
  • nums[i] > 0 时，此时我们要看 g[i - 1] 的值（这⾥请再读⼀遍 g[i - 1] 代表的意义。因为正数 * 负数 = 负数），根据 g[i - 1] 的值，⼜要分两种情况：
    • g[i - 1] = 0 ，说明以 i - 1 为结尾的乘积为负数的最⻓⼦数组是不存在的，⼜因为 nums[i] > 0 ，所以以 i 结尾的乘积为负数的最⻓⼦数组也是不存在的，此时 f[i] = 0 ；
    • g[i - 1] != 0 ，说明以 i - 1 为结尾的乘积为负数的最⻓⼦数组是存在的，⼜因为 nums[i] > 0 ，所以以 i 结尾的乘积为正数的最⻓⼦数组就等于 g[i -1] + 1 ；

综上所述， nums[i] > 0 时， g[i] = g[i - 1] == 0 ? 0 : g[i - 1] +1 ;

这⾥的推导⽐较绕，因为不断的出现「正数和负数」的分情况讨论，我们只需根据下⾯的规则，严格找到此状态下需要的 dp 数组即可：

  • 正数 * 正数 = 正数
  • 负数 * 负数 = 正数
  • 负数 * 正数 = 正数 * 负数 = 负数
  1. 初始化：

可以在最前⾯加上⼀个「辅助结点」，帮助我们初始化。使⽤这种技巧要注意两个点：

  • 辅助结点⾥⾯的值要「保证后续填表是正确的」；
  • 「下标的映射关系」。

在本题中，最前⾯加上⼀个格⼦，并且让 f[0] = g[0] = 0 即可。

  1. 填表顺序：

根据「状态转移⽅程」易得，填表顺序为「从左往右，两个表⼀起填」。

  1. 返回值：

根据「状态表⽰」，我们要返回 f 表中的最⼤值。

🚩代码实现

class Solution {
    public int getMaxLen(int[] nums) {
        int n = nums.length;
        int[] f = new int[n + 1];
        int[] g = new int[n + 1];
        int ret = Integer.MIN_VALUE;
        for(int i = 1; i <= n; i++) {
            if(nums[i - 1] > 0) {
                f[i] = f[i - 1] + 1;
                g[i] = g[i - 1] == 0 ? 0 : g[i - 1] + 1;
            } else if(nums[i - 1] < 0) {
                f[i] = g[i - 1] == 0 ? 0 : g[i - 1] + 1;
                g[i] = f[i - 1] + 1;
            }
            ret = Math.max(ret, f[i]);
        }
        return ret;
    }
}

在这里插入图片描述

🌳等差数列划分

🚩题目描述

如果一个数列 至少有三个元素 ，并且任意两个相邻元素之差相同，则称该数列为等差数列。

例如，[1,3,5,7,9]、[7,7,7,7] 和 [3,-1,-5,-9] 都是等差数列。

给你一个整数数组 nums ，返回数组 nums 中所有为等差数组的 子数组 个数。

子数组 是数组中的一个连续序列。

  • 示例 1：
    输入：nums = [1,2,3,4]
    输出：3
    解释：nums 中有三个子等差数组：[1, 2, 3]、[2, 3, 4] 和 [1,2,3,4] 自身。
  • 示例 2：
    输入：nums = [1]
    输出：0
class Solution {
    public int numberOfArithmeticSlices(int[] nums) {

    }
}

🚩算法思路：

  1. 状态表⽰：

由于我们的研究对象是「⼀段连续的区间」，如果我们状态表⽰定义成 [0, i] 区间内⼀共有多少等差数列，那么我们在分析 dp[i] 的状态转移时，会⽆从下⼿，因为我们不清楚前⾯那么多的「等差数列都在什么位置」。

所以说，我们定义的状态表⽰必须让等差数列「有迹可循」，让状态转移的时候能找到「⼤部队」。因此，我们可以「固定死等差数列的结尾」，定义下⾯的状态表⽰：

dp[i] 表⽰必须「以 i 位置的元素为结尾」的等差数列有多少种。

  1. 状态转移⽅程：

我们需要了解⼀下等差数列的性质：如果 a b c 三个数成等差数列，这时候来了⼀个 d ，其中 b c d 也能构成⼀个等差数列，那么 a b c d 四个数能够成等差序列吗？答案是：显然的。

因为他们之间相邻两个元素之间的差值都是⼀样的。有了这个理解，我们就可以转⽽分析我们的状态转移⽅程了。

对于 dp[i] 位置的元素 nums[i] ，会与前⾯的两个元素有下⾯两种情况：

  • nums[i - 2], nums[i - 1], nums[i] 三个元素不能构成等差数列：那么以nums[i] 为结尾的等差数列就不存在，此时 dp[i] = 0 ；
  • nums[i - 2], nums[i - 1], nums[i] 三个元素可以构成等差数列：那么以nums[i - 1] 为结尾的所有等差数列后⾯填上⼀个 nums[i] 也是⼀个等差数列，此时dp[i] = dp[i - 1] 。

但是，因为 nums[i - 2], nums[i - 1], nums[i] 三者⼜能构成⼀个新的等差数列，因此要在之前的基础上再添上⼀个等差数列，于是 dp[i] = dp[i - 1] + 1 。

综上所述：状态转移⽅程为：

当： nums[i - 2] + nums[i] != 2 * nums[i - 1] 时， dp[i] = 0
当： nums[i - 2] + nums[i] == 2 * nums[i - 1] 时， dp[i] = 1 + dp[i -1]

  1. 初始化：

由于需要⽤到前两个位置的元素，但是前两个位置的元素⼜⽆法构成等差数列，因此 dp[0] =
dp[1] = 0

  1. 填表顺序：

毫⽆疑问是「从左往右」。

  1. 返回值：

因为我们要的是所有的等差数列的个数，因此需要返回整个 dp 表⾥⾯的元素之和

🚩代码实现

class Solution {
    public int numberOfArithmeticSlices(int[] nums) {
        int n = nums.length;
        int result = 0;
        int[] dp = new int[n ];
        for (int i = 2; i < n; i++) {
            if((nums[i] - nums[i - 1]) == (nums[i - 1] - nums[i - 2])) {
                dp[i] = dp[i - 1] + 1;
            } else {
                dp[i] = 0;
            }
            result += dp[i];
        }
        return result;
    }
}

🍀最长湍流子数组

🚩题目描述

给定一个整数数组 arr ，返回 arr 的 最大湍流子数组的长度 。

如果比较符号在子数组中的每个相邻元素对之间翻转，则该子数组是 湍流子数组 。

更正式地来说，当 arr 的子数组 A[i], A[i+1], …, A[j] 满足仅满足下列条件时，我们称其为湍流子数组：

若 i <= k < j ：
当 k 为奇数时， A[k] > A[k+1]，且当 k 为偶数时，A[k] < A[k+1]；

或 若 i <= k < j ：
当 k 为偶数时，A[k] > A[k+1] ，且当 k 为奇数时， A[k] < A[k+1]。

  • 示例 1：
    输入：arr = [9,4,2,10,7,8,8,1,9]
    输出：5
    解释：arr[1] > arr[2] < arr[3] > arr[4] < arr[5]
  • 示例 2：
    输入：arr = [4,8,12,16]
    输出：2
  • 示例 3：
    输入：arr = [100]
    输出：1
class Solution {
    public int maxTurbulenceSize(int[] arr) {

    }
}

🚩思路解析

  1. 状态表⽰：

我们先尝试定义状态表⽰为：

dp[i] 表⽰「以 i 位置为结尾的最⻓湍流数组的⻓度」。

但是，问题来了，如果状态表⽰这样定义的话，以 i 位置为结尾的最⻓湍流数组的⻓度我们没法从之前的状态推导出来。因为我们不知道前⼀个最⻓湍流数组的结尾处是递增的，还是递减的。因此，我们需要状态表⽰能表⽰多⼀点的信息：要能让我们知道这⼀个最⻓湍流数组的结尾是「递增」的还是「递减」的。因此需要两个 dp 表：

f[i] 表⽰：以 i 位置元素为结尾的所有⼦数组中，最后呈现「上升状态」下的最⻓湍流数组的⻓度；

g[i] 表⽰：以 i 位置元素为结尾的所有⼦数组中，最后呈现「下降状态」下的最⻓湍流数组的⻓度。

  1. 状态转移⽅程：

对于 i 位置的元素 arr[i] ，有下⾯三种情况：

  • arr[i] > arr[i - 1] ：如果 i 位置的元素⽐ i - 1 位置的元素⼤，说明接下来应该去找 i -1 位置结尾，并且 i - 1 位置元素⽐前⼀个元素⼩的序列，那就是 g[i- 1] 。更新 f[i] 位置的值： f[i] = g[i - 1] + 1 ；
  • arr[i] < arr[i - 1] ：如果 i 位置的元素⽐ i - 1 位置的元素⼩，说明接下来应该去找 i - 1 位置结尾，并且 i - 1 位置元素⽐前⼀个元素⼤的序列，那就是 f[i - 1] 。更新 g[i] 位置的值： g[i] = f[i - 1] + 1 ；
  • arr[i] == arr[i - 1] ：不构成湍流数组。
  1. 初始化：

所有的元素「单独」都能构成⼀个湍流数组，因此可以将 dp 表内所有元素初始化为1 。由于⽤到前⾯的状态，因此我们循环的时候从第⼆个位置开始即可。

  1. 填表顺序：

毫⽆疑问是「从左往右，两个表⼀起填」。

  1. 返回值：

应该返回「两个 dp 表⾥⾯的最⼤值」，我们可以在填表的时候，顺便更新⼀个最⼤值

🚩代码实现

class Solution {
    public int maxTurbulenceSize(int[] arr) {
        // 1. 创建 dp 表
        // 2. 初始化
        // 3. 填表
        // 4. 返回值
        int n = arr.length;
        int[] f = new int[n];
        int[] g = new int[n];
        for(int i = 0; i < n; i++) {
            f[i] = g[i] = 1;
        }
        int ret = 1;
        for(int i = 1; i < n; i++) {
            if(arr[i - 1] < arr[i]) {
                f[i] = g[i - 1] + 1;
            } else if(arr[i - 1] > arr[i]) {
                g[i] = f[i - 1] + 1;
            }
            ret = Math.max(ret, Math.max(f[i], g[i]));
        }
        return ret;
    }
}

🌲单词拆分

🚩题目描述

给你一个字符串 s 和一个字符串列表 wordDict 作为字典。如果可以利用字典中出现的一个或多个单词拼接出 s 则返回 true。

注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。

  • 示例 1：
    输入: s = “leetcode”, wordDict = [“leet”, “code”]
    输出: true
    解释: 返回 true 因为 “leetcode” 可以由 “leet” 和 “code” 拼接成。
  • 示例 2：
    输入: s = “applepenapple”, wordDict = [“apple”, “pen”]
    输出: true
    解释: 返回 true 因为 “applepenapple” 可以由 “apple” “pen” “apple” 拼接成。注意，你可以重复使用字典中的单词。
  • 示例 3：
    输入: s = “catsandog”, wordDict = [“cats”, “dog”, “sand”, “and”, “cat”]
    输出: false
class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {

    }
}

🚩算法思路：

  1. 状态表⽰：

对于线性 dp ，我们可以⽤「经验+题⽬要求」来定义状态表⽰：

  • 以某个位置为结尾，进行一系列操作；
  • 以某个位置为起点，进行一系列操作。

这⾥我们选择⽐较常⽤的⽅式，以某个位置为结尾，结合题⽬要求，定义⼀个状态表⽰：

dp[i] 表⽰： [0, i] 区间内的字符串，能否被字典中的单词拼接⽽成。

  1. 状态转移⽅程：

对于 dp[i] ，为了确定当前的字符串能否由字典⾥⾯的单词构成，根据最后⼀个单词的起始位置 j ，我们可以将其分解为前后两部分：

  • 前⾯⼀部分 [0, j - 1] 区间的字符串；
  • 后⾯⼀部分 [j, i] 区间的字符串。

其中前⾯部分我们可以在 dp[j - 1] 中找到答案，后⾯部分的⼦串可以在字典⾥⾯找到。

因此，我们得出⼀个结论：当我们在从 0 ~ i 枚举 j 的时候，只要 dp[j - 1] = true 并且后⾯部分的⼦串 s.substr(j, i - j + 1) 能够在字典中找到，那么dp[i] =true 。

  1. 初始化：

可以在最前⾯加上⼀个「辅助结点」，帮助我们初始化。使⽤这种技巧要注意两个点：

  • 辅助结点⾥⾯的值要「保证后续填表是正确的」；
  • 「下标的映射关系」。

在本题中，最前⾯加上⼀个格⼦，并且让 dp[0] = true ，可以理解为空串能够拼接⽽成。

其中为了⽅便处理下标的映射关系，我们可以将字符串前⾯加上⼀个占位符 s = ’ ’ + s ，这样就没有下标的映射关系的问题了，同时还能处理「空串」的情况。

  1. 填表顺序：

显⽽易⻅，填表顺序「从左往右」。

  1. 返回值：

由「状态表⽰」可得：返回 dp[n] 位置的布尔值。

这里我们再引入哈希表优化的⼩细节：

在状态转移中，我们需要判断后⾯部分的⼦串「是否在字典」之中，因此会「频繁的⽤到查询操作」。为了节省效率，我们可以提前把「字典中的单词」存⼊到「哈希表」中。

🚩代码实现：

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        // 1. 创建 dp 表
        // 2. 初始化
        // 3. 填表
        // 4. 返回值
        // 优化⼀：将字典⾥⾯的单词存在哈希表⾥⾯
        Set<String> hash = new HashSet(wordDict);
        int n = s.length();
        boolean[] dp = new boolean[n + 1];
        dp[0] = true; // 初始化，保证我们后续填表是正确的
        s = " " + s; // 处理下标的映射关系
        for(int i = 1; i <= n; i++) {
            // 填 dp[i]
            for(int j = i; j >= 1; j--) {
                //最后⼀个单词的起始位置
                if(dp[j - 1] && hash.contains(s.substring(j, i + 1))) {
                    dp[i] = true;
                    break; // 优化⼆
                }
            }
        }
        return dp[n];
    }
}

🎍环绕字符串中唯一的子字符串

🚩题目描述

定义字符串 base 为一个 “abcdefghijklmnopqrstuvwxyz” 无限环绕的字符串，所以 base 看起来是这样的：

  • “…zabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd…”.

给你一个字符串 s ，请你统计并返回 s 中有多少 不同非空子串 也在 base 中出现。

  • 示例 1：
    输入：s = “a”
    输出：1
    解释：字符串 s 的子字符串 “a” 在 base 中出现。
  • 示例 2：
    输入：s = “cac”
    输出：2
    解释：字符串 s 有两个子字符串 (“a”, “c”) 在 base 中出现。
  • 示例 3：
    输入：s = “zab”
    输出：6
    解释：字符串 s 有六个子字符串 (“z”, “a”, “b”, “za”, “ab”, and “zab”) 在 base 中出现。
class Solution {
    public int findSubstringInWraproundString(String s) {

    }
}

🚩算法思路：

  1. 状态表⽰：

对于线性 dp ，我们可以⽤「经验+题⽬要求」来定义状态表⽰：

  • 以某个位置为结尾，进行一系列操作；
  • 以某个位置为起点，进行一系列操作。

这⾥我们选择⽐较常⽤的⽅式，以某个位置为结尾，结合题⽬要求，定义⼀个状态表⽰：

dp[i] 表⽰：以 i 位置的元素为结尾的所有⼦串⾥⾯，有多少个在 base 中出现过。

  1. 状态转移⽅程：

对于 dp[i] ，我们可以根据⼦串的「⻓度」划分为两类：

  • ⼦串的⻓度等于 1 ：此时这⼀个字符会出现在 base 中；
  • ⼦串的⻓度⼤于 1 ：如果 i 位置的字符和 i - 1 位置上的字符组合后，出现在 base中的话，那么 dp[i - 1] ⾥⾯的所有⼦串后⾯填上⼀个 s[i] 依旧在 base 中出现。因此 dp[i] = dp[i - 1] 。

综上， dp[i] = 1 + dp[i - 1] ，其中 dp[i - 1] 是否加上需要先做⼀下判断。

  1. 初始化：

可以根据「实际情况」，将表⾥⾯的值都初始化为 1 。

  1. 填表顺序：

显⽽易⻅，填表顺序「从左往右」。

  1. 返回值：

这⾥不能直接返回 dp 表⾥⾯的和，因为会有重复的结果。在返回之前，我们需要先「去重」：

  • 相同字符结尾的 dp 值，我们仅需保留「最⼤」的即可，其余 dp 值对应的⼦串都可以在最⼤的⾥⾯找到；

  • 可以创建⼀个⼤⼩为 26 的数组，统计所有字符结尾的最⼤ dp 值。最后返回「数组中所有元素的和」即可。

🚩代码实现

class Solution {
    public int findSubstringInWraproundString(String ss) {
        int n = ss.length();
        char[] s = ss.toCharArray();
        // 1. 利⽤ dp 得到每⼀个位置为结尾的最⻓连续数组的⻓度
        int[] dp = new int[n];
        for(int i = 0; i < n; i++) {
            dp[i] = 1;
        }
        for(int i = 1; i < n; i++) {
            if (s[i - 1] + 1 == s[i] || (s[i - 1] == 'z' && s[i] == 'a')) {
                dp[i] += dp[i - 1];
            }
        }
        // 2. 去重
        int[] hash = new int[26];
        for (int i = 0; i < n; i++) {
            hash[s[i] - 'a'] = Math.max(hash[s[i] - 'a'], dp[i]);
        }
        // 3. 返回结果
        int sum = 0;
        for(int x : hash) {
            sum += x;
        }
        return sum;
    }
}

⭕总结

关于《【算法优选】 动态规划之子数组、子串系列——贰》就讲解到这儿，感谢大家的支持，欢迎各位留言交流以及批评指正，如果文章对您有帮助或者觉得作者写的还不错可以点一下关注，点赞，收藏支持一下！

遇事问春风乄
关注
  • 19
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
2024华为OD机试（JAVA）真题【A卷+B卷+C卷+D卷】目录
MISAYAONE的博客
11-20 23万+
2022.11 开始华为机试 Od 应该加新题了，优先更新最新的题目。
2024华为OD机试（Python）真题【A卷+B卷+C卷+D卷】目录
热门推荐
MISAYAONE的博客
11-20 18万+
2022.11 开始机试应该是换新题库了，优先更新最新的题目。
【算法优选】 动态规划之子数组、子串系列——壹
m0_71731682的博客
05-14 1097
动态规划相关题目都可以参考以下五个步骤进行解答：状态表示状态转移⽅程初始化填表顺序返回值后面题的解答思路也将按照这五个步骤进行讲解。
【C++刷题】优选算法——动态规划第五辑
阿顺的学习记录。
04-22 204
1.最长公共子序列 2.不相交的线 3.不同的子序列 4.通配符匹配 5.正则表达式匹配 6.交错字符串 7.两个字符串的最小ASCII删除和 8.最长重复子数组
【C++刷题】优选算法——动态规划第三辑
阿顺的学习记录。
04-11 233
1.最大子数组和 2.环形子数组的最大和 3.乘积最大子数组 4.乘积为正数的最长子数组长度 5.等差数列划分 6.最长湍流子数组 7.单词拆分 8.环绕字符串中唯一的子字符串 9.最长递增子序列 10.摆动序列 11.最长递增子序列的个数 12.最长数对链 13.最长定差子序列 14.最长的斐波那契子序列的长度 15.最长等差数列 16.等差数列划分 II - 子序列
【C++刷题】优选算法——动态规划第四辑
阿顺的学习记录。
04-17 312
1.回文子串 2.最长回文子串 3.分割回文串 IV 4.分割回文串 II 5.最长回文子序列 6.让字符串成为回文串的最少插入次数
【优选算法】—— 字符串匹配算法
m0_56069910的博客
08-22 537
字符串匹配算法详解
【算法优选】 滑动窗口专题——贰
m0_71731682的博客
10-06 1099
基本概念滑动窗口是一种基于双指针的一种思想，两个指针指向的元素之间形成一个窗口。分类：窗口有两类，一种是固定大小类的窗口，一类是大小动态变化的窗口。一起加油。
【算法优选】 滑动窗口专题——壹
m0_71731682的博客
10-03 1955
基本概念滑动窗口是一种基于双指针的一种思想，两个指针指向的元素之间形成一个窗口。分类：窗口有两类，一种是固定大小类的窗口，一类是大小动态变化的窗口。一起加油。
动态规划——最长公共子序列和最长公共子串之Python实现
10-22
用Python实现动态规划中最长公共子序列和最长公共子串问题！
python实现对求解最长回文子串的动态规划算法
09-20
主要为大家详细介绍了python实现对求解最长回文子串的动态规划算法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
面试必考字符串相关的动态规划——最大公共子序列、最大公共子串、编辑距离
12-21
字符串相关的动态规划最大公共子序列最大公共子串编辑距离 简述这三个算法解决的问题和展示状态转移方程并且给出可通过执行的Python代码。 最大公共子序列 子序列是，一个字符串中的任意字符组成的序列，重点在于，...
算法合集之《后缀数组——处理字符串的有力工具》
07-13
后缀数组的倍增算法和DC3算法的实现以及不可重叠重复子串的问题，很详细的资料
python解决最长回文子串，使用动态规划思想解决
12-31
一个算法中的经典问题，求最长回文子串问题，其实是可以归于二维动态规划问题。 对于给定的一个字符串中，找到这个字符串中的回文子串，回文子串的概念是从前往后正向的读和从后往前反向的读都是完全相同的字符串。
力扣LCP 08.剧情触发时间
最新发布
Pisasama的博客
06-12 309
【代码】力扣LCP 08.剧情触发时间。
牛客网刷题 | BC118 N个数之和
m0_64000959的博客
06-09 467
目前主要分为三个专栏，后续还会添加： 专栏如下： C语言刷题解析 C语言系列文章 我的成长经历感谢阅读！初来乍到，如有错误请指出，感谢！输入数字N，然后输入N个数，计算这N个数的和。第一行输入一个整数N(0≤N≤50)，第二行输入用空格分隔的N个整数。输出为一行，为第二行输入的“N个整数之和”的计算结果。使用数组的方式 先将用户输入的几个数字分别存起来定义一个变量将它数字的和加起来然后输出 代码 2 ： 输入n个数相加，应该想到循
LeetCode 算法：轮转数组c++
小金牛来了
06-09 654
LeetCode 算法：轮转数组c++
每日两题6
FZC206的博客
06-09 298
删除并获得点数 + 粉刷房子
利用动态规划算法求最长公共子串
04-28
最长公共子串问题可以通过动态规划算法来解决。 假设有两个字符串S1和S2，它们的长度分别为m和n。定义dp[i][j]为S1以第i个字符结尾、S2以第j个字符结尾的最长公共子串的长度。 那么，当S1[i] == S2[j]时，dp[i][j] = dp[i-1][j-1] + 1；否则，dp[i][j] = 0。 最后，我们只需要在dp数组中找到最大值即可。 详细的动态规划算法实现如下： ``` int longestCommonSubstring(string s1, string s2) { int m = s1.length(); int n = s2.length(); int dp[m+1][n+1]; int ans = 0; memset(dp, 0, sizeof(dp)); // 初始化dp数组为0 for (int i = 1; i <= m; i++) { for (int j = 1; j <= n; j++) { if (s1[i-1] == s2[j-1]) { dp[i][j] = dp[i-1][j-1] + 1; ans = max(ans, dp[i][j]); } else { dp[i][j] = 0; } } } return ans; } ``` 其中，max()函数用于求最大值，memset()函数用于初始化数组为0。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

遇事问春风乄

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值