子序列问题

已于 2023-06-05 08:51:58 修改
阅读量105 收藏
点赞数
分类专栏： 算法 文章标签： 算法 leetcode java 动态规划
于 2023-06-02 10:55:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shu0shuo/article/details/131002781
版权
文章介绍了使用动态规划解决几种不同类型的子序列问题，包括最长递增子序列、最长重复子数组、最长公共子序列、不相交的线、判断子序列、不同的子序列和编辑距离。每种问题都详细解析了dp数组的含义、递推公式、初始化和遍历顺序。
摘要由CSDN通过智能技术生成

子序列问题

300. 最长递增子序列

如果没接触过这种题目的话，本题还是很难的。 子序列问题是动态规划解决的经典问题，当前下标i的递增子序列长度，其实和i之前的下表j的子序列长度有关系，

用动规五部曲来详细分析一波：

  1. dp[i]表示i之前包括i的以nums[i]结尾的最长递增子序列的长度

    做 递增比较的时候，如果比较 nums[j] 和 nums[i] 的大小，那么两个递增子序列一定分别以nums[j]为结尾 和 nums[i]为结尾， 要不然这个比较就没有意义了

  2. 递推公式

    位置i的最长升序子序列等于j从0到i-1各个位置的最长升序子序列 + 1 的最大值,这句话可以好好理解下，比较拗口。

    if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);

  3. dp[i]的初始化

    每一个i，对应的dp[i]（即最长递增子序列）起始大小至少都是1.

  4. 确定遍历顺序

    dp[i] 是有0到i-1各个位置的最长递增子序列 推导而来，那么遍历i一定是从前向后遍历。j其实就是遍历0到i-1，那么是从前到后，还是从后到前遍历都无所谓，只要吧 0 到 i-1 的元素都遍历了就行了。 所以默认习惯 从前向后遍历。

    遍历i的循环在外层，遍历j则在内层

    class Solution {
    public int lengthOfLIS(int[] nums) {
        int[] dp = new int[nums.length];
        Arrays.fill(dp, 1);
        for (int i = 0; i < dp.length; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
        }
        int res = 0;
        for (int i = 0; i < dp.length; i++) {
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}

718. 最长重复子数组

题目中没有明确说明，求的其实是连续的最长公共子数组，要求是连续的。

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

    dp[i][j] ：以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复子数组长度为dp[i][j]。

    为什么不以i，j结尾呢，因为这样结尾初始化回方便一些。

  2. 递推公式

    即当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;

    可能有的同学想不明白为什么这样就能保证是连续相等，可以想一下dp数组的定义：下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复子数组长度为dp[i][j]。

    如果前面的不相等，则dp[i - 1][j - 1] = 0，就相当于是从头开始计数了。

  3. 初始化

    根据dpi的定义，dp[i][0] 和dp[0][j]其实都是没有意义的！

    但dpi 和dp0要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;

    所以dp[i][0] 和dp[0][j]初始化为0。

  4. 顺序

    外层for循环遍历A，内层for循环遍历B。

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int res = 0;
        int[][] dp = new int[nums1.length+1][nums2.length+1];
        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;
                    res = Math.max(dp[i][j], res);
                }
            }
        }
        return res;
    }
}

1143. 最长公共子序列

本题和上一题718. 最长重复子数组的唯一区别就是：本题不要求连续了。

那在代码上的区别就是递推公式会有所变化，其他都一样，我们这里着重讲一下递推公式。

dp[i][j]只有两种情况，

  • chars1[i-1] == chars2[j-1]:相等的时候，和上一题的情况是一样的，直接dp[i][j] = dp[i-1][j-1]+1;

  • chars1[i-1] != chars2[j-1]:不等的时候，需要整理出前面两个数组中哪个情况下重合的比较多，就选哪个

    例如：abc和ace,比较到下标为2时，c!=e。故需要看一下abc和ac以及ab和ace哪个重合部分比较多。

    在代码上就是dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);

class Solution {
   public int longestCommonSubsequence(String text1, String text2) {
        char[] chars1 = text1.toCharArray();
        char[] chars2 = text2.toCharArray();
        int[][] dp = new int[text1.length()+1][text2.length()+1];
        for (int i = 1; i <= chars1.length; i++) {
            for (int j = 1; j <= chars2.length; j++) {
                if (chars1[i-1] == chars2[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[chars1.length][chars2.length];
    }
}

1035. 不相交的线

本题比较接近应用题的范畴了，看起来毫无头绪，但是如果准化成我们做的的题，就好做多了。

首先我们要搞清楚，题目到底要求的是什么，其实最大连线数，就是最长公共子序列。

要求连线不交叉，就是要求两个相同的子序列要尽可能的长嘛。

所以本题和上一题1143. 最长公共子序列的代码是一模一样的。没有任何变化。只要变个变量名就行

class Solution {
    public int maxUncrossedLines(int[] nums1, int[] nums2) {
        int[][] dp = new int[nums1.length+1][nums2.length+1];
        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;
                }else {
                    dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
                }
            }
        }
        return dp[nums1.length][nums2.length];
    }
}

392. 判断子序列

本题和1143. 最长公共子序列是很像的，两者的差别在于，一个要求找出两个字符串的最长公共子序列，一个要看s是否是y的子序列。

所以再相等的时候，这两道题的递推公式都是一样的

if (chars1[i-1] == chars2[j-1]) {
    dp[i][j] = dp[i-1][j-1]+1;
}

区别就在于不同时候的处理。

本题因为s是不动的，所以每次发现不同的时候，把t往回删一个即可，s是不用动的

if(s.charAt(i-1) == t.charAt(j-1)) {
    dp[i][j] = dp[i-1][j-1] + 1;
} else {
    dp[i][j] = dp[i][j-1];
}

整体代码如下

class Solution {
    public boolean isSubsequence(String s, String t) {
        int[][] dp = new int[s.length()+1][t.length()+1];
        for(int i = 1; i <= s.length(); i++) {
            for(int j = 1; j <= t.length(); j++) {
                if(s.charAt(i-1) == t.charAt(j-1)) {
                    dp[i][j] = dp[i-1][j-1] + 1;
                } else {
                    dp[i][j] = dp[i][j-1];
                }
            }
        }
        if(dp[s.length()][t.length()] == s.length()) {
            return true;
        }else {
            return false;
        }
    }
}

115. 不同的子序列

本题相对于上一题难度又提升了一截，但是核心思路还是一样的，这次再完整的走一遍动规五部曲

  1. dp数组：

    dp[i][j]：以i-1为结尾的s子序列中出现以j-1为结尾的t的个数为dp[i][j]。这句话可能有些拗口，但是其实就是题目所求，只不过我们这里给定义成了i-1和j-1.为了方便初始化，前面也讲过原因。

  2. 递推公式

    本题难就难在，递推公式真的不是很好想，倒也不是公式复杂，就是脑子绕不过来。总共有两种情况

    • s[i - 1] 与 t[j - 1]相等

      • 用s[i - 1] 匹配，个数就是dp[i-1][j-1]

      • 不用s[i - 1] 匹配，个数就是dp[i-1][j]。此处不是很好理解，比如s = bagg, t = bag。s[3] 和 t[2]是相同的，但是字符串s也可以不用s[3]来匹配，即用s[0]s[1]s[2]组成的bag。

      故s[i - 1] 与 t[j - 1]相等的时候，dp[i][j] = dp[i-1][j-1] + dp[i-1][j];

    • s[i - 1] 与 t[j - 1] 不相等

      不相等的时候就比较简单了，dp[i][j]只有一部分组成，不用s[i - 1]来匹配（就是模拟在s中删除这个元素），即：dp[i - 1][j]

    if(s.charAt(i-1) == t.charAt(j-1)) {
    dp[i][j] = dp[i-1][j-1] + dp[i-1][j];
}else {
    dp[i][j] = dp[i-1][j];
}

  3. 初始化

    我们由递推公式可以看到，dp[i][j]完全是由i-1，j和i-1，j-1组成的。而且没有在此基础上进行+1或者自增的操作，所以，肯定是不能设为0的。

    dp[i][0] 表示：以i-1为结尾的s可以随便删除元素，出现空字符串的个数。

    那么dp[i][0]一定都是1，因为也就是把以i-1为结尾的s，删除所有元素，出现空字符串的个数就是1。

    dp[0][j]：空字符串s可以随便删除元素，出现以j-1为结尾的字符串t的个数。

    那么dp[0][j]一定都是0，s如论如何也变成不了t。

    dp[0][0]应该是1，空字符串s，可以删除0个元素，变成空字符串t。

    for(int i = 0; i < s.length(); i++) {
    dp[i][0] = 1;
}

  4. 确定遍历数组

    从上到下，从左到右，这样保证dpi可以根据之前计算出来的数值进行计算。

class Solution {
    public int numDistinct(String s, String t) {
        int[][] dp = new int[s.length()+1][t.length()+1];
        //初始化
        for(int i = 0; i < s.length(); i++) {
            dp[i][0] = 1;
        }
        for(int i = 1; i <= s.length(); i++) {
            for(int j = 1; j <= t.length(); j++) {
                if(s.charAt(i-1) == t.charAt(j-1)) {
                    dp[i][j] = dp[i-1][j-1] + dp[i-1][j];
                }else {
                    dp[i][j] = dp[i-1][j];
                }
            }
        }
        return dp[s.length()][t.length()];
    }
}

392. 判断子序列

本题和上一题很像，也是属于不相等就删除的，只不过上一题只在一个字符串中删除，本题需要在两个字符串中删除。

  1. p数组：以i-1为结尾的word1和以j-1为结尾的word2，需要删除的字符个数。

  2. 递推公式：

    • 相等： dp[i][j] = dp[i-1][j-1];

    • 不相等：

      • dp[i][j] = dp[i-1][j] + 1;

      • dp[i][j] = dp[i][j-1] + 1;

      • dp[i][j] = dp[i-1][j-1] + 2;和前两种重复了，可以不考虑

      dp[i][j] = Math.min(dp[i-1][j] + 1, dp[i][j-1] + 1);

  3. 初始化：根据dp数组的具体含义来想

    for(int i = 0 ; i <= word1.length(); i++) {
    dp[i][0] = i;
}
for(int i = 0 ; i <= word2.length(); i++) {
    dp[0][i] = i;
}

  4. 遍历顺序：dp[i][j]都是根据左上方、正上方、正左方推出来的。

    所以遍历的时候一定是从上到下，从左到右，这样保证dp[i][j]可以根据之前计算出来的数值进行计算。

class Solution {
    public int minDistance(String word1, String word2) {
        int[][] dp = new int[word1.length()+1][word2.length()+1];
        //初始化
        for(int i = 0 ; i <= word1.length(); i++) {
            dp[i][0] = i;
        }
        for(int i = 0 ; i <= word2.length(); i++) {
            dp[0][i] = i;
        }
        for(int i = 1; i<= word1.length(); i++) {
            for(int j = 1; j<= word2.length(); 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, dp[i][j-1] + 1);
                }
            }
        }
        return dp[word1.length()][word2.length()];
    }
}

115. 不同的子序列

本题相对于上一题难度又提升了一截，但是核心思路还是一样的，这次再完整的走一遍动规五部曲

  1. dp数组：

    dp[i][j]：以i-1为结尾的s子序列中出现以j-1为结尾的t的个数为dp[i][j]。这句话可能有些拗口，但是其实就是题目所求，只不过我们这里给定义成了i-1和j-1.为了方便初始化，前面也讲过原因。

  2. 递推公式

    本题难就难在，递推公式真的不是很好想，倒也不是公式复杂，就是脑子绕不过来。总共有两种情况

    • s[i - 1] 与 t[j - 1]相等

      • 用s[i - 1] 匹配，个数就是dp[i-1][j-1]

      • 不用s[i - 1] 匹配，个数就是dp[i-1][j]。此处不是很好理解，比如s = bagg, t = bag。s[3] 和 t[2]是相同的，但是字符串s也可以不用s[3]来匹配，即用s[0]s[1]s[2]组成的bag。

      故s[i - 1] 与 t[j - 1]相等的时候，dp[i][j] = dp[i-1][j-1] + dp[i-1][j];

    • s[i - 1] 与 t[j - 1] 不相等

      不相等的时候就比较简单了，dp[i][j]只有一部分组成，不用s[i - 1]来匹配（就是模拟在s中删除这个元素），即：dp[i - 1][j]

    if(s.charAt(i-1) == t.charAt(j-1)) {
    dp[i][j] = dp[i-1][j-1] + dp[i-1][j];
}else {
    dp[i][j] = dp[i-1][j];
}

  3. 初始化

    我们由递推公式可以看到，dp[i][j]完全是由i-1，j和i-1，j-1组成的。而且没有在此基础上进行+1或者自增的操作，所以，肯定是不能设为0的。

    dp[i][0] 表示：以i-1为结尾的s可以随便删除元素，出现空字符串的个数。

    那么dp[i][0]一定都是1，因为也就是把以i-1为结尾的s，删除所有元素，出现空字符串的个数就是1。

    dp[0][j]：空字符串s可以随便删除元素，出现以j-1为结尾的字符串t的个数。

    那么dp[0][j]一定都是0，s如论如何也变成不了t。

    dp[0][0]应该是1，空字符串s，可以删除0个元素，变成空字符串t。

    for(int i = 0; i < s.length(); i++) {
    dp[i][0] = 1;
}

  4. 确定遍历数组

    从上到下，从左到右，这样保证dpi可以根据之前计算出来的数值进行计算。

class Solution {
    public int numDistinct(String s, String t) {
        int[][] dp = new int[s.length()+1][t.length()+1];
        //初始化
        for(int i = 0; i < s.length(); i++) {
            dp[i][0] = 1;
        }
        for(int i = 1; i <= s.length(); i++) {
            for(int j = 1; j <= t.length(); j++) {
                if(s.charAt(i-1) == t.charAt(j-1)) {
                    dp[i][j] = dp[i-1][j-1] + dp[i-1][j];
                }else {
                    dp[i][j] = dp[i-1][j];
                }
            }
        }
        return dp[s.length()][t.length()];
    }
}

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

本题和上一题很像，也是属于不相等就删除的，只不过上一题只在一个字符串中删除，本题需要在两个字符串中删除。

  1. p数组：以i-1为结尾的word1和以j-1为结尾的word2，需要删除的字符个数。

  2. 递推公式：

    • 相等： dp[i][j] = dp[i-1][j-1];

    • 不相等：

      • dp[i][j] = dp[i-1][j] + 1;

      • dp[i][j] = dp[i][j-1] + 1;

      • dp[i][j] = dp[i-1][j-1] + 2;和前两种重复了，可以不考虑

      dp[i][j] = Math.min(dp[i-1][j] + 1, dp[i][j-1] + 1);

  3. 初始化：根据dp数组的具体含义来想

    for(int i = 0 ; i <= word1.length(); i++) {
    dp[i][0] = i;
}
for(int i = 0 ; i <= word2.length(); i++) {
    dp[0][i] = i;
}

  4. 遍历顺序：dp[i][j]都是根据左上方、正上方、正左方推出来的。

    所以遍历的时候一定是从上到下，从左到右，这样保证dp[i][j]可以根据之前计算出来的数值进行计算。

class Solution {
    public int minDistance(String word1, String word2) {
        int[][] dp = new int[word1.length()+1][word2.length()+1];
        //初始化
        for(int i = 0 ; i <= word1.length(); i++) {
            dp[i][0] = i;
        }
        for(int i = 0 ; i <= word2.length(); i++) {
            dp[0][i] = i;
        }
        for(int i = 1; i<= word1.length(); i++) {
            for(int j = 1; j<= word2.length(); 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, dp[i][j-1] + 1);
                }
            }
        }
        return dp[word1.length()][word2.length()];
    }
}

72. 编辑距离

本题可以说是非常经典的一道困难题目了，据说字节面试的时候会经常考。下面我们就来一起仔细的分析下。

首先我们来分析下题目，题目中明确指明可以进行插入、删除、替换三个操作。

删除操作我们是很熟悉的，上面的诸多题目都是用的删除操作。

使用动规五部曲来进行分析。

  1. 确定dp数组含义

    dp[i][j] 表示以下标i-1为结尾的字符串word1，和以下标j-1为结尾的字符串word2，最近编辑距离为dp[i][j]。

    至于为什么要定义为以i-1和j-1为结尾，前面的题目我们也说过了，是为了方便初始化。

  2. 确定推到公式：

    我们还是分情况讨论

    • 当前字符相等：(word1.charAt(i-1) == word2.charAt(j-1)

      相等的时候是不用进行任何操作的，即值和上一位的最近编辑距离相同：dp[i][j] = dp[i-1][j-1];

    • 当前字符不相等：(word1.charAt(i-1) != word2.charAt(j-1)

      • 删除：删除情况我们之前有过很详尽的分析了，本题是在word1和word2删除都可以。于是公式为：

        dp[i][j] = Math.min(dp[i-1][j],dp[i][j-1]) + 1

      • 插入：插入其实本质上是删除的逆过程，比如：word1 = "ab", word2 = "a"。

        如果按照插入的理解就是word2末尾插入一个b，按删除就是word1删除一个b。虽然插入和删除最后的出的单词是不同的，但是操作数是相同的，所以本题我们呢可以把插入和删除看作同一操作。

      • 替换：替换在本题dp数组的定义下其实就是word1和word2前一位的操作数+1。

        dp[i][j] = dp[i-1][j-1] + 1

    所以整体的递推公式为：dp[i][j] = Math.min(dp[i-1][j-1],Math.min(dp[i-1][j],dp[i][j-1])) + 1;

  3. 初始化：

    我们想一下dp数组的定义就可以很清楚的知道该怎么进行舒适化了。

    dp[i][0] ：以下标i-1为结尾的字符串word1，和空字符串word2，最近编辑距离为dp[i][0]。那么dpi就应该是i，对word1里的元素全部做删除操作，即：dp[i][0] = i;那么dp[i][0] 同理。

    for(int i = 0; i <= word1.length(); i++) {
    dp[i][0] = i;
}
for(int j = 0; j <= word2.length(); j++) {
    dp[0][j] = j;
}

  4. 遍历顺序

    根据递推公式可以看出dpi是依赖左方，上方和左上方元素的。所以在dp矩阵中一定是从左到右从上到下去遍历。

class Solution {
    public int minDistance(String word1, String word2) {
        int[][] dp = new int[word1.length()+1][word2.length()+1];
​
        for(int i = 0; i <= word1.length(); i++) {
            dp[i][0] = i;
        }
        for(int j = 0; j <= word2.length(); j++) {
            dp[0][j] = j;
        }
        for(int i = 1; i <= word1.length(); i++) {
            for(int j = 1; j <= word2.length(); 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],Math.min(dp[i-1][j],dp[i][j-1])) + 1;
                }
            }
        }
        return dp[word1.length()][word2.length()];
    }
}
最长公共子序列问题详解
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
04-14 1848
最长公共子序列问题（Longest Common Subsequence, LCS）是计算机科学中一个经典的动态规划问题。它在多个领域都有广泛的应用，如生物信息学中的DNA序列比对、版本控制系统中的文本比较、自然语言处理中的文本相似度计算等。本文将详细介绍最长公共子序列问题的定义、性质、解决方法，并通过伪代码和C语言代码来具体展示如何实现这一算法。
动态规划之子序列问题
小朱小朱绝不认输的博客
11-26 3564
文章目录一、动态规划之子序列问题二、leetcode例题讲解子序列问题1. 子序列（不连续）300. 最长递增子序列1143. 最长公共子序列1035. 不相交的线2. 子序列（连续）674. 最长连续递增序列718. 最长重复子数组53. 最大子序和3. 编辑距离392. 判断子序列115. 不同的子序列583. 两个字符串的删除操作72. 编辑距离4. 回文串647. 回文子串516. 最长回文子序列 子序列问题是动态规划中一系列常见的问题，有多个种类，这里对动态规划的子序列问题进行汇总。 一、动态规划
DP：子序列问题
2301_79969994的博客
07-02 1934
在计算机科学和数学中，子序列（Subsequence）是指从一个序列中删除一些元素（可以是零个或多个），但不改变其余元素相对顺序后形成的新序列。子序列的特点元素的相对顺序保持不变。可以删除零个或多个元素。一个序列的子序列可以为空序列，即不包含任何元素。举例说明设有序列 S = [A, B, C, D, E]，则其子序列可以有：删除零个元素：[A, B, C, D, E]（即自身）
子序列问题详解
LJIONG的博客
03-18 1708
线性动态规划——子序列问题 （有错误欢迎指出，部分解法灵感来源于洛谷题解） 文章目录线性动态规划——子序列问题1.最长上升子序列（LIS，Longest Increasing Subsequence）1.1 动态规划1.1.1 状态转移方程1.1.2 时间复杂度1.1.3 代码1.2树状数组优化1.2.1 思路1.2.2 时间复杂度1.2.3 具体操作1.2.4 代码2.其他子序列问题2.1 最长...
详解最长公共子序列问题（三种方法）
热门推荐
CXR_XC的博客
03-30 1万+
C++分别利用三种动态规划解决最长公共子序列问题
最长公共子序列问题
qq_44875145的博客
04-28 2971
动态规划之最长公共子序列问题 1.问题描述： 输入两个字符串 输出最长公共子序列的长度。若最大公共子序列的长度大于0，则还会输出一个最大公共子序列。 举例： cnblogs与belong 4 blog (注意：子序列是不连续的，而子串是连续的。但它们的字符出现顺序均与所输入字符串的字母先后顺序一致。) 2.求解最大公共子序列的长度 思路分析： 假设k为最长公共子序列的长度。 (1).如果s...
最长公共子序列问题（动态规划）
m0_52124992的博客
03-28 7854
最长公共子序列问题 动态规划
动态规划算法04-最长递增子序列问题
周先森爱吃素的博客
03-24 1441
最长递增子序列问题。 简述 经典的动态规划问题。 问题描述 给定一个序列，求解其中长度最长的递增子序列。 问题分析 这种可以向下查询答案的很容易想到动态规划的解法。 要求长度为i的序列Ai={a1,a2,a3,ai}的最长递增子序列，需要先求出序列Ai-1{a1,a2,a3,ai-1}中各元素(a1,a1,ai-1)作为最大元素的最长递增子序列，然后将这i-1个递增序列与ai进...
最长递增子序列问题
LOVETEDA的博客
02-25 2062
题目描述 给定数组arr，设长度为n，输出arr的最长递增子序列。（如果有多个答案，请输出其中字典序最小的） 输入描述: 输出两行，第一行包括一个正整数n（n<=100000），代表数组长度。第二行包括n个整数，代表数组arr \left(1 \leq arr_i \leq 1e9 \right)(1≤arri​≤1e9)。 输出描述: 输出一行。代表你求出的最长的递增子序列。...
求解最长公共子序列问题LCSlength(debug).cpp
05-08
【问题描述】字符序列的子序列是指从给定字符序列中随意地（不一定要联系）去掉若干个字符（可能一个也不去掉）后所形成的字符序列。给定两个序列A和B，称序列Z是A和B的公共子序列，是指Z同是A和B的子序列，该问题是...
实验2. 动态规划法求解最长公共子序列问题与0-1背包问题.doc
02-06
动态规划法求解最长公共子序列问题与0-1背包问题 本实验报告旨在通过动态规划法解决最长公共子序列问题和0-1背包问题，以深入理解动态规划方法的思想、求解策略及步骤。 实验目的 * 理解动态规划方法的核心思想和...
最长公共子序列问题.docx
06-14
总的来说，通过动态规划法，我们可以有效地解决最长公共子序列问题，找到两个字符序列的最长共同部分，这在生物信息学、文本比较、数据压缩等领域有着广泛的应用。在实践中，理解并熟练掌握动态规划的思想和步骤，...
实验2. 动态规划法求解最长公共子序列问题&0-1背包问题.doc
01-12
“动态规划法求解最长公共子序列问题&0-1背包问题” 动态规划是一种非常重要的算法设计方法，应用于解决很多复杂的问题。动态规划法可以将问题分解成若干个小问题，然后通过解决每个小问题来解决整个问题。在实验2...
算法基础-链表
August的专栏
11-05 220
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
字符串-06-整数与ip地址之间的转换
qq_45480682的博客
11-04 328
华为od算法——HJ33
【LeetCode】【算法】160.相交链表
最新发布
passer__jw767的博客
11-05 305
Leetcode 160. 相交链表
二叉树(一)
m0_74340589的博客
11-05 431
/ 写递归算法的关键是要明确函数的「定义」是什么，然后相信这个定义，利用这个定义推导最终结果，绝不要试图跳入递归。// 再说说归并排序的逻辑，若要对nums[lo…// 再看看回溯算法，前文回溯算法详解干脆直接说了，回溯算法就是个 N 叉树的前后序遍历问题，没有例外。// 其实很多动态规划问题就是在遍历一棵树，你如果对树的遍历操作烂熟于心，起码知道怎么把思路转化成代。//快速排序的逻辑是，若要对nums[lo….所有回溯、动归、分治算法，其实都是树的问题，而树的问题就永远逃不开树的递归遍历。
JavaCV 图像边缘检测 之 Sobel算子 算法
欢迎拜读我的作品，喜欢的领域请给我留言
11-04 1504
JavaCV 是一个基于 OpenCV 和 FFmpeg 的 Java 计算机视觉库。它提供了对各种计算机视觉算法和图像处理功能的访问，包括图像读取、处理、显示，以及视频处理等。JavaCV 封装了底层的 C/C++ 库，使得在 Java 中进行计算机视觉开发更加方便快捷。本文详细介绍了JavaCV中的Sobel 算子在边缘检测中的应用。从Sobel 算子的原理出发，阐述了一阶导数与边缘检测的关系，以及Sobel 算子的卷积核和边缘检测过程。接着介绍了JavaCV的简介和Maven。
C语言实现求解最长公共子序列问题
最长公共子序列问题是指，在两列或多列序列中找到一个最长的子序列，这个子序列在两列序列中都出现，但不必在两列序列中具有相同的顺序。这里的“子序列”指的是一列序列的某个序列保持原来顺序但不必连续。 2. LCS...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值