动态规划（四）子序列、编辑距离

已于 2023-06-25 20:17:55 修改
阅读量127 收藏 1
点赞数
分类专栏： 算法 文章标签： 动态规划 算法 leetcode
于 2023-06-08 18:33:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41029475/article/details/131058486
版权

子序列问题

子序列可能拥有的性质：

  1. 连续：即子数组（数组场景）、子串（字符串场景）
  2. 递增

解题总结：

  • 子序列可以是不连续的；
  • 子数组（子字符串）需要是连续的；
  • 当单个数组或者字符串要用动态规划时，可以把动态规划dp[i]定义为nums[0:i] 中想要求的结果；
  • 当两个数组或者字符串要用动态规划时，可以把动态规划定义成两维的 dp[i][j] ，其含义是在A[0:i−1] 与B[0:j−1] 之间匹配得到的想要的结果。
  • DP数组定义为以nums[i]为结尾，需要遍历dp数组来得到结果；定义为范围[0,i-1]内，则dp的最后一个元素即为结果
  • DP数组定义为 数量，最后一位相等时需要考虑不使用最后一位的情况，定义为长度则直接+1

1、单个序列，最长递增类

300. 最长递增子序列（递增子序列）

  1. 子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序
  2. 解题步骤：
  • dp数组含义：以下标i为结尾的最长递增子序列的长度

要求序列有序，所以必须确定序列最后一个元素的值，才能比较新加入序列的元素是不是递增的

  • 递推公式：for(j<i, nums[i] > nums[j])：dp[i] = max(dp[j]+1, dp[i]) 。位置i的最长升序子序列等于j从0到i-1各个位置的最长升序子序列 + 1 的最大值，取dp[j] + 1的最大值
  • 初始化：dp[i] = 1
  • 遍历顺序：dp[i] 是由0到i-1各个位置的最长递增子序列 推导而来。用i从小到大遍历子序列，代表以nums[i]为结尾的子序列。再用j遍历0到i-1，计算dp[i]。
  1. 结果：在以下标i为结尾的最长递增子序列的长度中取最大值
class Solution {
    public int lengthOfLIS(int[] nums) {
        int[] dp = new int[nums.length];
        int res = 0;
        for(int i = 0; i < nums.length; i++){
            dp[i] = 1;
            for(int j = 0; j < i; j++){
                if(nums[i] > nums[j])   dp[i] = Math.max(dp[i],dp[j]+1);
            }
            res = Math.max(dp[i],res);
        }
        return res;
    }
}

674. 最长连续递增序列（递增子数组）

  1. 解题步骤：
  • dp数组含义：以下标i为结尾的连续递增的子序列长度为dp[i]。一定是以下标i为结尾，并不是说一定以下标0为起始位置
  • 递推公式：if( nums[i] > nums[i-1])：dp[i] = dp[i-1] + 1 。本题要求连续递增子序列，所以就只要比较nums[i]与nums[i - 1]，而不用去比较nums[j]与nums[i] （j是在0到i之间遍历）
  • 初始化：dp[i] = 1
  1. 结果：在所有以下标i为结尾的最长连续递增子序列的长度中取最大值
动态规划
class Solution {
    public int findLengthOfLCIS(int[] nums) {
        if(nums.length == 1)    return 1;
        int res = 0;
        int[] dp = new int[nums.length];
        for(int i = 0; i < nums.length; i++){
            dp[i] = 1;
        }
        for(int i = 1; i < nums.length; i++){
            if(nums[i] > nums[i-1]) dp[i] = dp[i-1] + 1;
            res = Math.max(res,dp[i]);
        }
        return res;
    }
}
贪心
class Solution {
    public int findLengthOfLCIS(int[] nums) {
        if(nums.length == 1)    return 1;
        int res = 0;
        int max = 1;
        for(int i = 1; i < nums.length; i++){
            if(nums[i] > nums[i-1]) max++;
            else{
                max = 1;
            }
            res = Math.max(max,res);
        }
        return res;
    }
}

2、两个序列

718. 最长重复子数组（子数组）

  1. 子数组其实是连续子序列
  2. 解题步骤：
  • dp数组含义：以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复子数组长度为dp[i][j]。“以下标i - 1为结尾的A” 标明一定是 以A[i-1]为结尾的子数组

求连续相等子序列，则必须确定序列最后一个元素的值

  • 递推公式：
    • 当nums1[i - 1] 和nums2[j - 1]相等时， dp[i][j]的状态由dp[i - 1][j - 1]推导出来，故 dp[i][j] = dp[i-1][j-1] + 1；
    • 当nums1[i - 1] 和nums2[j - 1]不相等时，由于子数组的连续性，前缀数组不能为它们俩提供公共长度，故dp[i][j] = 0
  • 初始化：长度为0时，dp[0][j] = 0 ,dp[i][0] = 0
  • 遍历顺序：从小到大，先遍历nums1或者nums2都可以，遍历时记录最大值
class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int[][] dp = new int[nums1.length+1][nums2.length+1];
        int res = 0;
        for(int i = 1; i <= nums1.length; i++){
            for(int j = 1; j <= nums2.length; j++){
                if(nums1[i-1] == nums2[j-1])    dp[i][j] = dp[i-1][j-1] + 1;
                //表明了一定是以下标i为结尾
                else dp[i][j] = 0; 
                res = Math.max(dp[i][j], res);
            }
        }
        return res;
    }
}
  1. 结果：题目要求长度最长的子数组的长度。所以在遍历的时候顺便把dp[i][j]的最大值记录下来。

1143. 最长公共子序列（子序列）

  1. 元素可以不连续；
  2. 解题步骤：
  • dp数组含义：[0, i - 1]范围内的字符串text1与[0, j - 1]范围内的字符串text2的最长公共子序列长度为dp[i][j]

求不必连续的相等子序列，就不需要知道序列最后一个元素的值，只要知道范围内相等的序列长度就行，新来的相等元素可以直接加在序列后面

  • 递推公式：
    • if( text1[i-1] == text2[j-1]), dp[i][j] = dp[i - 1][j - 1] + 1。必然使用text1[i-1] 与 text2[j-1] 时
    • if(text1[i-1] != text2[j-1]), dp[i][j] = max(dp[i-1][j],dp[i][j-1])。必然不使用text1[i-1] 与 必然不使用 text2[j-1] 时
  • 遍历顺序
  • 举例推导： text1[i-1] 不等于 text2[j-1]的情况下，比如对于 ace 和 bc 而言，他们的最长公共子序列的长度等于 ① ace 和 b 的最长公共子序列长度0 与 ② ac 和 bc 的最长公共子序列长度1 的最大值，即 1。
class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int len1 = text1.length(), len2 = text2.length();
        int[][] dp = new int[len1 + 1][len2 + 2];
        int res = 0;
        for(int i = 1; i <= len1; i++){
            for(int j = 1; j <= len2; j++){
                if(text1.charAt(i-1) == text2.charAt(j-1)) dp[i][j] = dp[i-1][j-1] + 1;
                //这里就说明了不一定以text1[i-1]和text2[j-1]为结尾
                else    dp[i][j] = Math.max(dp[i-1][j],dp[i][j-1]);
            }
        }
        return dp[len1][len2];
    }
}
  1. 结果：按照dp数组的定义，dp[text1.size()][text2.size()]就为最终结果

1035. 不相交的线（子序列）

实际上求的就是最长公共子序列

class Solution {
    public int maxUncrossedLines(int[] nums1, int[] nums2) {
        int len1 = nums1.length;
        int len2 = nums2.length;
        int[][] dp = new int[len1+1][len2+1];
        for(int i = 1; i <= len1; i++){
            for(int j = 1; j <= len2; j++){
                if(nums1[i-1] ==  nums2[j-1])   dp[i][j] = dp[i-1][j-1] + 1;
                else    dp[i][j] = Math.max(dp[i-1][j],dp[i][j-1]);
            }
        }
        return dp[len1][len2];
    }
}

53. 最大子数组和（子数组）

动态规划
  1. 解题步骤：
  • dp含义：以nums[i]为结尾的最大连续子序列和为dp[i]
  • 递推公式：dp[i] = Math.max(nums[i]，dp[i-1]+nums[i])
  • 初始化：dp[0] = nums[0], res = dp[0]
  1. 结果：要找最大的连续子序列，就应该找每一个i为终点的连续最大子序列。遍历时维护一个最大的dp[i]。
class Solution {
    public int maxSubArray(int[] nums) {
        int[] dp = new int[nums.length];
        dp[0] = nums[0];
        int res = dp[0];
        for(int i = 1; i < nums.length; i++){
            dp[i] = Math.max(nums[i],dp[i-1]+nums[i]);
            res = Math.max(dp[i],res);
        }
        return res;
    }
}
贪心解法

思路：计算累加和，计算后每次都要比较更新一遍最大值，如果累计和小于0则重置累加和为0，代表从下个元素开始重新计算。
思路简单，但是代码比较难写，错误较多

class Solution {
    public int maxSubArray(int[] nums) {
        int sum = 0;
        int res = -10010;
        for(int i = 0; i < nums.length; i++){
            sum+=nums[i];
            res = Math.max(res,sum);
            if(sum < 0) sum = 0;
        }
        return res;
    }
}

3、编辑距离类

392. 判断子序列（子序列）

动态规划
  1. 编辑距离的入门题目，因为从题意中我们也可以发现，只需要计算删除的情况，不用考虑增加和替换的情况
  2. 问题等价转换在 t 中找到和 s 相同子序列的长度 == s 的大小
  3. 解题步骤：
  • dp数组含义：[0, i - 1]范围内的字符串s与[0, j - 1]范围内的字符串t的相同子序列长度为dp[i][j]
  • 递推公式：
    • if s[i−1]==t[j−1], dp[i][j]=dp[i−1][j−1]+1。必然使用s[i-1] 与 t[j-1] 时
    • if s[i−1]!=t[j−1], dp[i][j]=dp[i][j−1]。必然不使用 t[j-1] 时
  • 初始化
  • 遍历顺序
class Solution {
    public boolean isSubsequence(String s, String t) {
        int slen = s.length();
        int tlen = t.length();
        int[][] dp = new int[slen+1][tlen+1];
        for(int i = 1; i <= slen; i++){
            for(int j = 1; j <= tlen; j++){
                if(s.charAt(i-1) == t.charAt(j-1))  dp[i][j] = dp[i-1][j-1] + 1;
                //表明了不一定要以t[j-1]为结尾，但是一定要以s[i-1]为结尾
                else    dp[i][j] = dp[i][j-1];
            }
        }
        return dp[slen][tlen] == slen;
    }
}
暴力
class Solution {
    public boolean isSubsequence(String s, String t) {
        if(t.length() == 0 && s.length() != 0)   return false;
        if(s.length() == 0)   return true;
        int slen = s.length();
        int tlen = t.length();
        int c = 0;
        for(int i = 0; i < tlen; i++){
            if(s.charAt(c) == t.charAt(i)){
                c++;
                if(c == slen)   return true;
            }
        }
        return false;
    }
}

115. 不同的子序列（子序列）

  1. 解题步骤：
  • dp数组含义：[0, i - 1]范围内的字符串s，其子序列中出现j-1为结尾的字符串t的个数为dp[i][j]
  • 递推公式：
    • if s[i-1] == t[j-1]，dp[i][j] = dp[i-1][j-1] + dp[i-1][j]。使用s[i-1]的情况+考虑不使用s[i-1]的情况；
    • if s[i-1] != t[j-1]，dp[i][j] = dp[i-1][j]。只考虑不使用s[i-1]的情况。

为什么还要考虑 不用s[i - 1]来匹配。例如： s：bagg 和 t：bag ，s[3] 和 t[2]是相同的，但是字符串s也可以不用s[3]来匹配，即用s[0]s[1]s[2]组成的bag。

  • 初始化：d[i][0] = 1，dp[0][j] = 0，dp[0][0] = 1；
  • 遍历顺序
  • 举例推导
class Solution {
    public int numDistinct(String s, String t) {
        int slen = s.length();
        int tlen = t.length();
        int[][] dp = new int[slen+1][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.charAt(i-1) == t.charAt(j-1))  dp[i][j] = dp[i-1][j-1] + dp[i-1][j];
                //表明了不一定以s[i-1]为结尾，但是一定以t[j-1]为结尾
                else    dp[i][j] = dp[i-1][j];
            }
        }
        return dp[slen][tlen];
    }
}

583. 两个字符串的删除操作（子序列）

  1. 两个字符串可以相互删
  2. 解题步骤：
  • dp数组：[0, i - 1]范围内的字符串word1，和[0, j - 1]范围内的字符串word2，形成相同字符串的最小删除次数
  • 递推公式：
    • if word1[i - 1] == word2[j - 1], dp[i][j] = dp[i-1][j-1] ；
    • if word1[i - 1] != word2[j - 1], dp[i][j] = min(dp[i-1][j-1]+2,dp[i-1][j]+1,dp[i][j-1]+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][0] = i，dp[0][j] = j
  • 遍历顺序
  • 举例推导
class Solution {
    public int minDistance(String word1, String word2) {
        int w1len = word1.length();
        int w2len = word2.length();
        int[][] dp = new int[w1len+1][w2len+1];
        for(int i = 0; i <= w1len; i++)  dp[i][0] = i;
        for(int j = 0; j <= w2len; j++)  dp[0][j] = j;
        for(int i = 1; i <= w1len; i++){
            for(int j = 1; j <= w2len; j++){
                if(word1.charAt(i-1) == word2.charAt(j-1)){
                    dp[i][j] = dp[i-1][j-1];
                }else{
                    dp[i][j] = Math.min(dp[i-1][j-1]+2,Math.min(dp[i-1][j],dp[i][j-1])+1);
                }
            }
        }
        return dp[w1len][w2len];
    }
}

72. 编辑距离（子序列）

  1. 可以删除、添加、替换
  2. 解题步骤：
  • dp数组：[0, i - 1]范围内的字符串word1，和[0, j - 1]范围内的字符串word2，最近编辑距离为dp[i][j]
  • 递推公式：
    • if (word1[i - 1] == word2[j - 1]), dp[i][j] = dp[i - 1][j - 1]。
    • if (word1[i - 1] != word2[j - 1]), dp[i][j] = min(dp[i][j] = dp[i - 1][j] , dp[i][j] = dp[i][j - 1] , dp[i][j] = dp[i - 1][j - 1] ) + 1。操作一：word1删除一个元素；操作二：word2删除一个元素；操作三：替换元素。word2添加一个元素，相当于word1删除一个元素
  • 初始化：dp[i][0] = i，dp[0][j] = j
  • 遍历顺序
  • 举例推导
class Solution {
    public int minDistance(String word1, String word2) {
        int w1len = word1.length();
        int w2len = word2.length();
        int[][] dp = new int[w1len+1][w2len+1];
        //dp[i][j]:[0,i-1],[0,j-1]
        for(int i = 0; i <= w1len; i++) dp[i][0] = i;
        for(int j = 0; j <= w2len; j++) dp[0][j] = j;
        for(int i = 1; i <= w1len; i++){
            for(int j = 1; j <= w2len; j++){
                if(word1.charAt(i-1) == word2.charAt(j-1)){
                    dp[i][j] = dp[i-1][j-1];
                }else{
                    dp[i][j] = Math.min(Math.min( dp[i - 1][j], dp[i][j - 1]),dp[i - 1][j - 1]) + 1;
                }
            }
        }
        return dp[w1len][w2len];
    }
}

4、回文类

647. 回文子串（子串）

  1. 解题思路：判断一个子字符串[i,j]是否回文，依赖于，子字符串[i + 1, j - 1]是否是回文。若子字符串[i,j]回文，则res++。用二维的DP数组来表示一段范围内的字符串是否为回文字符串
  2. 解题步骤：
  • dp数组含义：dp[i][j]表示[i, j]范围内的字串是否为回文子串
  • 递推公式：
    • if( dp[i] != dp[j]), d[i][j] = false
    • if (dp[i] == dp[j])。（1）if( i == j || j - i == 1)，dp[i][j] = true，比如a，aa。（2）if( j - i > 1 ), dp[i][j] = dp[i+1][j-1]，看子字符串[i + 1, j - 1]是否是回文
  • 初始化：dp[i][j] = false
  • 遍历顺序： dp[i][j]依赖于dp[i+1][j-1]，遍历i时从大往小，遍历j时从小往大
    遍历顺序
class Solution {
    public int countSubstrings(String s) {
        int len = s.length();
        int res = 0;
        char[] str = s.toCharArray();
        boolean[][] dp = new boolean[len][len];
        for(int i = len - 1; i >= 0; i--){
            for(int j = i; j < len; j++){
                if(str[i] == str[j]){
                    if(j - i <= 1)  dp[i][j] = true;
                    else    dp[i][j] = dp[i+1][j-1];
                }
                if(dp[i][j])    res++;
            }
        }
        return res;
    }
}

516. 最长回文子序列（子序列）

  1. 解题步骤：
  • dp数组含义：字符串s在[i, j]范围内最长回文子序列的长度为dp[i][j]
  • 递推公式：
    • if( dp[i] != dp[j]), dp[i][j] = max(dp[i+1][j],dp[i][j-1])。分别加入s[i]、s[j]看看哪一个可以组成最长的回文子序列；
    • if (dp[i] == dp[j])。（1）if( i == j )，dp[i][j] = 1，比如a。（2）if( j > i ), dp[i][j] = dp[i+1][j-1]+2
  • 初始化：dp[i][i] = 1，这里的初始化过程搬到了递推公式时做
  • 遍历顺序：遍历i时从大往小，遍历j时从小往大
class Solution {
    public int longestPalindromeSubseq(String s) {
        char[] str = s.toCharArray();
        int len = s.length();
        int[][] dp = new int[len][len];
        for(int i = len - 1; i >= 0; i--){
            for(int j = i; j < len; j++){
                if(str[i] == str[j]){
                    if(j == i)  dp[i][j] = 1;
                    else    dp[i][j] = dp[i+1][j-1]+2;
                }else{
                    dp[i][j] = Math.max(dp[i+1][j],dp[i][j-1]);
                }
            }
        }
        return dp[0][len-1];
    }
}

混淆点

1. 为什么两个子序列最后一位相等时，有时需要考虑不使用最后一位的情况？

看dp数组的含义，题目《1143. 最长公共子序列》中DP数组定义的是长度，最后一位相等时，确实是长度+1，而题目《115. 不同的子序列》中DP数组定义的是数量，最后一位相等时，长度确实时+1，但是数量=使用最后一位的数量+不使用最后一位的数量。
因此题目《392. 判断子序列》可以将DP定义为长度或者是数量，解法都没有问题

2. DP数组定义为：（1）以nums[i-1]为结尾；（2）[0, i - 1]范围内，不一定以nums[i-1]为结尾

AerialAce
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态规划之子序列问题
小朱小朱绝不认输的博客
11-26 2092
文章目录一、动态规划之子序列问题二、leetcode例题讲解子序列问题1. 子序列（不连续）300. 最长递增子序列1143. 最长公共子序列1035. 不相交的线2. 子序列（连续）674. 最长连续递增序列718. 最长重复子数组53. 最大子序和3. 编辑距离392. 判断子序列115. 不同的子序列583. 两个字符串的删除操作72. 编辑距离4. 回文串647. 回文子串516. 最长回文子序列 子序列问题是动态规划中一系列常见的问题，有多个种类，这里对动态规划的子序列问题进行汇总。 一、动态规划
求数组中两个元素最小距离(动态规划)
没有感情的刷题机器
02-14 1242
要求： 给定一个数组，数组中含有重复元素，给定两个数字num1和num2，求这两个数字在数组中出现位置的最小距离。 分析： 方法一：蛮力法 主要思路为：对数组进行双重遍历，外层循环遍历查找num1，只要遍历到num1，内层循环对数组从头开始遍历找num2，每当遍历到num2，就计算他们距离dist。当遍历结束后最小的dist值就是他们最小的距离。 ...
动态规划—编辑距离（一）解析+代码
m0_72563041的博客
06-26 178
编辑距离（一）
动态规划之编辑距离
黄波波的博客
07-06 580
Leetcode 72 编辑距离 本文层层递进，一共使用了五种方法，用Python解决了编辑距离问题。其根本思想是使用动态规划算法，根据状态转移方程即可求解。 给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数 。 你可以对一个单词进行如下三种操作： 插入一个字符 删除一个字符 替换一个字符 这个问题从直观上给人是很难的，但是在实际应用中非常常见。如下面的例子：输入法自动更正，当输入是左边的单词时，输入法会自动猜测到kitchen,而不是与实际输入差
leetcode-------编辑距离
qq_41983709的博客
03-25 85
解法是参考的别人的题解： class Solution { public: int minDistance(string word1, string word2) { int n1 = word1.size(); int n2 = word2.size(); vector<vector<int>> dp...
编辑距离总结
m0_46388866的博客
10-27 222
1.编辑距离 动态规划思路（自底向上） 这道题其实和前面的两个字符删除操作极其的相似，只不过是状态需要好好地捋清楚。 dp[i] [j]这里的i的意思就是word1前i个字符，word2前j个字符，如果要把word1改成word2所需要的最少操作。这里的把word1改成word2非常重要，必须理清楚关系是word1改成word2，重要的事说三遍。知道这个之后后面的状态转移才有可能捋清楚 如果word1[i]==word[j]那么就可以什么都不做 如果不相等就会有三种情况 dp[i] [j
动态规划---编辑距离
m0_51431003的博客
10-03 1819
动态规划---编辑距离系列问题
面试必考字符串相关的动态规划——最大公共子序列、最大公共子串、编辑距离
12-21
字符串相关的动态规划最大公共子序列最大公共子串编辑距离 简述这三个算法解决的问题和展示状态转移方程并且给出可通过执行的Python代码。 最大公共子序列 子序列是，一个字符串中的任意字符组成的序列，重点在于，...
设计一个动态规划算法求解最长公共子序列问题设计一个动态规划算法解决编辑距离问题
03-21
求X和Y的最长公共子序列长度以及最长公共子序列 2 对于给定的字符串A和字符串B，编程计算其编辑距离d(A,B)。 随机产生20以上的字符，放入输入文件input.txt，如：X={A,B,C,B,D,A,B}和Y={B,D,C,A,B,A}。 程序运行结束...
基于C++实现编辑距离问题、货物堆积问题、骑士周游问题、数组分割问题、资源分配问题、最长上升子序列问题
04-12
最长上升子序列 编辑距离问题、货物堆积问题、骑士周游问题、数组分割问题、资源分配问题、最长上升子序列问题
最长公共子序列与最小编辑距离-你有更快的算法么？，排序算法数据结构
04-07
最长公共子序列与最小编辑距离-你有更快的算法么？，排序算法数据结构 最快的排序算法
什么是动态规划，及其解决的问题.md
04-13
3. **编辑距离问题**：计算两个字符串之间的最小编辑距离（将一个字符串转换为另一个字符串所需的最少操作次数）。 4. **0-1背包问题**：给定一组物品，每种物品都有自己的重量和价值，每种物品只有一个。在限定的总...
编辑距离算法详解：Levenshtein Distance算法
weixin_30909575的博客
07-01 1673
算法基本原理：假设我们可以使用d[ i , j ]个步骤（可以使用一个二维数组保存这个值），表示将串s[ 1…i ] 转换为 串t [ 1…j ]所需要的最少步骤个数，那么，在最基本的情况下，即在i等于0时，也就是说串s为空，那么对应的d[0,j] 就是 增加j个字符，使得s转化为t，在j等于0时，也就是说串t为空，那么对应的d[i,0] 就是 减少 i个字符，使得s转化为t。 然后我们...
算法-找出N个数组的共同元素
Python领域优质萌新创作者
06-02 494
3.1、使用集合的intersection_update方法，将当前编辑的新闻编号集合与common_news_set取交集，并更新common_news_set。1.1、使用集合的交集操作找出被所有编辑共同编辑过的新闻：遍历每个新闻集合进行交集操作，时间复杂度为O(K)，其中K为所有编辑操作的总数。3.2、这样，common_news_set中将保留与当前编辑共同编辑过的新闻编号，即找到所有编辑共同编辑过的新闻编号的交集。news_ids: 一个包含N个列表的列表，每个列表包含一个编辑编辑过的新闻编号。
理解和实现 LRU 缓存置换算法
最新发布
qq_41591215的博客
06-07 229
LRU算法的核心思想是：在缓存空间不足时，淘汰最长时间未被访问的数据项。这种策略适用于多种场景，包括Web缓存、数据库查询缓存、操作系统的页面置换等。
49. 字母异位词分组
qq_35085273的博客
06-04 1131
头好痛，不做了今天
leetcode 279.完全平方数
m0_73917165的博客
06-04 197
注意：初始化的时候并不能让dp[0]=0，因为当和为零的时候是没有完全平方数可以组成的，0也不是完全平方数，0的平方没有意义。然后再进行完全背包的筛选问题。这里将个数作为价值，都是1，容积其实就是数本身。可以首先预处理出来所谓的完全平方数有什么东西，存储到一个数组当中。思路：完全背包问题。
KMP算法（题目）
Ryan_hsMax的博客
06-04 522
题目描述：给定一个父字符串 s 和子字符串 p ，请按照从前向后的顺序，请求出 p 在 s 中所有出现的起始位置。例如：s=ABADABCEABABA，p=ABA，则求解的结果是：1 9 11。输入：第 1 行读入一个仅包含大写字母的字符串 s；第 2 行读入一个仅包含大写字母的字符串 p；s 和 p 均是长度不超过 106 的字符串。输出：输出 1 行，按题意输出 p 在 s 中出现的位置，数字之间用空格隔开。样例：输入：ABA输出：1 9 11。
代码随想录算法训练营day43
weixin_43390031的博客
06-07 744
遍历顺序，从背包容量大到小遍历；递推公式，和之前一样，当i能装进去的时候，dp[j]=max(dp[j],dp[j-stones[i]]+stones[i])；举例，这种不好想的题目，还是得举例的，nums=[1,1,1,1,1]，target=3，x=4，dp初始化为[1,0,0,0,0]，当i=0时，dp由递推公式计算的[1,1,0,0,0]，i=1时，[1,2,1,0,0]，i=2时，[1,3,3,1,0]，i=3时，[1,4,6,4,1]，i=4时，[1,5,10,10,5]，最终答案为5，符合。
动态规划求解编辑距离算法分析
07-29
编辑距离算法是一种常用的字符串相似度度量方法，它衡量两个字符串之间的差异程度。动态规划是解决编辑距离问题的常用方法之一。 编辑距离算法的目标是通过一系列的编辑操作（插入、删除、替换）将一个字符串转换成另一个字符串，使得转换的代价最小。代价可以通过插入、删除和替换操作的权重来定义，通常情况下插入和删除的代价为1，替换的代价为2。 动态规划算法解决编辑距离问题的思路是将原始问题分解为多个子问题，并利用子问题的最优解来求解原始问题的最优解。具体步骤如下： 1. 定义状态：假设两个字符串分别为s1和s2，定义dp[i][j]为将s1的前i个字符转换成s2的前j个字符所需要的最小编辑距离。 2. 初始化边界条件：将空字符串转换成任意字符串所需要的编辑距离为对应字符串的长度，即dp[0][j] = j，dp[i][0] = i。 3. 状态转移方程：根据题目要求和定义的状态，推导出状态转移方程。对于任意位置(i, j)，有以下三种情况： - 若s1的第i个字符等于s2的第j个字符，则不需要进行编辑操作，编辑距离与dp[i-1][j-1]相同，即dp[i][j] = dp[i-1][j-1]。 - 若s1的第i个字符不等于s2的第j个字符，则可以进行插入、删除或替换操作，选择代价最小的操作。具体操作可分别表示为： - 插入操作：将s1的前i个字符转换成s2的前j-1个字符，再插入s2的第j个字符，此时编辑距离为dp[i][j-1] + 1。 - 删除操作：将s1的前i-1个字符转换成s2的前j个字符，再删除s1的第i个字符，此时编辑距离为dp[i-1][j] + 1。 - 替换操作：将s1的前i-1个字符转换成s2的前j-1个字符，再将s1的第i个字符替换成s2的第j个字符，此时编辑距离为dp[i-1][j-1] + 2（若替换前后两个字符相同，则代价为0）。 综上所述，状态转移方程为：dp[i][j] = min(dp[i-1][j-1] + cost, dp[i][j-1] + 1, dp[i-1][j] + 1)，其中cost表示s1的第i个字符和s2的第j个字符是否相等。 4. 求解最优解：根据状态转移方程，利用动态规划自底向上地填充dp数组。最终，dp[m][n]即为将s1转换成s2所需要的最小编辑距离，其中m和n分别为s1和s2的长度。 通过动态规划求解编辑距离算法，可以高效地计算字符串间的相似度，并在自然语言处理、拼写检查、基因序列比对等领域得到广泛应用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值