如何解决子序列问题

已于 2023-02-07 13:38:42 修改
阅读量89 收藏
点赞数
分类专栏： 动态规划 文章标签： leetcode 动态规划 算法 Powered by 金山文档
于 2023-01-09 18:07:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46388493/article/details/128602859
版权

这篇是动态规划最后一篇文章，我感觉这类问题难度有点大，重点在子序列的元素在原序列当中是否连续。

子序列不连续问题

最长递增子序列

题目：300. 最长递增子序列 - 力扣（LeetCode）

  • dp数组及下标含义

dp[i]表示到第i个元素时，最长递增子序列的长度

  • 递推公式

如果dp[j] < dp[i]，dp[i] = max(dp[i], dp[j] + 1) j为0到i - 1的数

  • 初始化

全初始化为1，只有一个元素，则子序列长度为1

  • 遍历顺序

从小到大，因为dp[i]的值由下标比它小的值推出

int lengthOfLIS(vector<int> nums){
    int result = 0;
    vector<int> dp(nums.size(), 1);
    for(int i = 1; i < nums.size(); i++)
        for(int j = 0; j < i; j++){
            if(dp[j] < dp[i])
                dp[i] = max(dp[i], dp[j] + 1);
        }
        if(dp[i] > result)
            result = dp[i];
    }
    return result;
}

上述方法的时间复杂度为O()，在最长上升子序列(二)_牛客题霸_牛客网 (nowcoder.com)就会运行超时。下面介绍一种结合二分查找的动态规划方法。

dp[i]有两个来源：

  • 前面的数都比它大，则dp[i] = 1

  • 找到最长递增子序列中，替换第一个比它大的，可以让更多略大于它的数加入进来（贪心策略）

找出最长递增序列第一个比nums[i]大的下标，就可以使用二分查找

int lengthOfLIS(vector<int> nums){
    int result = 1;
    vector<int> number(nums.size(), nums[0]);
    for(int i = 1; i < nums.size(); i++){
        int low = 0, high = result;
        while(low < high){
            int mid = (low + high) / 2;
            if(number[mid] < nums[i])
                low = mid + 1;
            else
                high = mid;
        }
        if(low == result)
            result++;
        number[low] = nums[i];
    }
    return result;
}

最长公共子序列

题目：给定两个字符串text1和text2，返回两个字符串的最长公共子序列的长度。一个字符串的子序列是指：它由原字符串在不改变字符的相对顺序的情况下删除某些字符后组成的新字符串。

示例1：

输入：text1 = "abcde", text2 = "ace"

输出：3

示例2：

输入：text1 = "abc", text2 = "abc"

输出：3

示例3：

输入：text1 = "abc", text2 = "def"

输出：0

  • dp数组及下标含义

dp[i][j]表示text1下标i - 1之前部分与text2下标j - 1前的最长公共子序列长度

  • 递推公式

如果text1[i - 1] == text2[j - 1]，dp[i][j] = dp[i - 1][j - 1] + 1

如果不相等，dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])

  • 初始化

全都初始化为0

  • 遍历顺序

从小到大

int longestCommonSubsequence(string text1, string text2){
    vector<vector<int>> dp(text1.length() + 1, vector<int>(text2.length() + 1, 0));
    for(int i = 1; i <= text1.length(); i++){
        for(int j = 1; j <= text2.length(); j++){
            if(text1[i] == text2[j])
                dp[i][j] = dp[i - 1][j - 1] + 1;
            else
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
        }
    }
    return dp[text1.length()][text2.length()];
}

不同的子序列

题目：115. 不同的子序列 - 力扣（LeetCode）

  • dp数组及下标含义

dp[i][j]表示字符串s下标为i - 1的部分含t下标为j - 1部分的个数

  • 疑问：为什么dp数组的i表示字符串的下标为i - 1，而不是i？

  • 答：为了初始化简单，如果表示为下标i，以dp[0][j]为例，如果s[0] == t[0]，dp[0][0]初始化为1，反之，初始化为0，dp[0][j] = dp[0][j - 1]，如果s[0] == t[j]，dp[0][j] += 1

  • 递推公式

如果s[i - 1] == t[j - 1]，dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]

  • 疑问：为什么要加dp[i - 1][j]？

  • 答：因为s[i - 1]与t[j - 1]匹配，还可能与t[j]匹配

如果s[i - 1] != t[j - 1]，dp[i][j] = dp[i - 1][j]

  • 初始化

dp[0][j]都初始化为0，因为s为空字符串，不可能包含t

dp[i][0]都初始化为1，因为t为空字符串，s删除全部元素，就是t

  • 遍历顺序

从小到大

int numDistinct(string s, string t) {
    vector<vector<int>> dp(s.length() + 1, vector<int>(t.length() + 1, 0));
    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[i - 1] == t[i - 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()];
}

子序列连续问题

最长连续递增序列

题目：674. 最长连续递增序列 - 力扣（LeetCode）

  • dp数组及下标含义

dp[i]表示到第i个元素时，最长连续递增子序列的长度

  • 递推公式

如果(dp[i] > dp[i - 1])，dp[i] = dp[i - 1] + 1

  • 初始化

dp数组全部初始化为1

  • 遍历顺序

从小到大

int findLengthOfLCIS(vector<int> nums){
    int result = 1;
    vector<int> dp(nums.size(), 1);
    for(int i = 1; i < nums.size(); i++){
        if(dp[i] > dp[i - 1])
            dp[i] = dp[i - 1] + 1;
        if(result < dp[i])
            result = dp[i];
    }
    return result;
}

最长重复子数组

题目：718. 最长重复子数组 - 力扣（LeetCode）

  • dp数组及下标含义

dp[i][j]表示数组A的下标i前部分和数组B的下标j前部分重复子数组的长度

  • 递推公式

如果A[i] == B[j]，dp[i][j] = dp[i - 1][j - 1] + 1

  • 初始化

如果A[i] == B[j]，dp[i][j] = 1，否则dp[i][j] = 0

  • 遍历顺序

从小到大

int findLength(vector<int> A, vector<int> B){
    int result = 0;
    vector<vector<int>> dp(A.size(), vector<int>(B.size(), 0));
    for(int i = 0; i < A.size(); i++){
        for(int j = 0; j < B.size(); j++){
            if(A[i] == B[j])
                dp[i][j] = 1;
        }
    }
    for(int i = 1; i < A.size(); i++){
        for(int j = 1; j < B.size(); j++){
            if(A[i] == B[j])
                dp[i][j] = dp[i - 1][j - 1] + 1;
            if(result < dp[i][j])
                result = dp[i][j];
        }
    }
    return result;
}

最大子序和

题目：53. 最大子数组和 - 力扣（LeetCode）

  • dp数组及下标含义

dp[i]表示[0, i]之间的连续子数组的最大和

  • 递推公式

dp[i] = max(dp[i - 1] + nums[i], nums[i])

  • 初始化

dp[0]初始化为nums[i]

  • 遍历顺序

从小到大

int maxSubArray(vector<int>& nums) {
    int result = 0;
    vector<int> dp(nums.size(), 0);
    dp[0] = nums[0];
    for(int i = 1; i < nums.size(); i++){
        dp[i] = max(dp[i - 1] + nums[i], nums[i])；
        if(result < dp[i])
            result = dp[i];
    }
    return result;
}

编辑距离

编辑距离

题目：给定两个单词word1和word2，计算出将word1转换成word2所使用的最少操作数。可以对一个单词进行如下三种操作：

  • 插入一个字符

  • 删除一个字符

  • 替换一个字符

示例1：

输入：word1 = "horse", word2 = "ros"

输出：3

示例2：

输入：word1 = "intention", word2 = "execution"

输出：5

解释：

intention -> inention

inention -> enention

enention -> exention

exention -> exection

exection -> execution

  • dp数组及下标含义

dp[i][j]表示将以下标i - 1结尾的word1转换为以下标j - 1结尾的word2最少需要的操作数

  • 递推公式

如果word1[i - 1] == word2[j - 1]，不需要编辑，dp[i][j] = dp[i - 1][j - 1]

反之，需要编辑

  • 增删操作（因为word1增加一个元素，相当于把word2对应元素删除，所以放一起）

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

  • 替换操作

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

综上，word1[i - 1] != word2[j - 1]时，dp[i][j] = min(dp[i - 1][j - 1], min(dp[i - 1][j], dp[i][j - 1]))

  • 初始化

dp[0][j]和dp[i][0]都是要把其中一个字符串转换为空串的最少操作数，即字符串的长度

  • 遍历顺序

从小到大

int minDistance(string word1, string word2){
    vector<vector<int>> dp(word1.length() + 1, vector<int>(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[i - 1] == word2[j - 1])
                dp[i][j] = dp[i - 1][j - 1];
            else
                dp[i][j] = min(dp[i - 1][j - 1], min(dp[i - 1][j], dp[i][j - 1])) + 1;
        }
    }
    return dp[word1.length()][word2.length()];
}

回文子串

回文子串

题目：647. 回文子串 - 力扣（LeetCode）

  • dp数组及下标含义

dp[i][j]表示下标i到下标j的部分是否为回文子串

  • 递推公式

如果s[i] != s[j]，dp[i][j] = false

如果s[i] == s[j]

  • j >= i + 2时，dp[i + 1][j - 1] == true，dp[i][j] = true

  • j < i + 2时，dp[i][j] = true

  • 初始化

全部初始化为false

  • 遍历顺序

i从大到小，j从小到大，j大于等于i

int countSubstrings(string s) {
    int result = 0;
    vector<vector<bool>> dp(s.length(), vector<bool>(s.length(), false);
    for(int i = s.length() - 1; i >= 0; i--){
        for(int j = i; j < s.length(); j++){
            if(s[i] == s[j]){
                if(j < i + 2){
                    dp[i][j] = true;
                    result++;
                }
                else if(dp[i + 1][j - 1] == true){
                        dp[i][j] = true;
                        result++;
                }
            }
        }
    }
    return result;
}

最长回文子序列

题目：516. 最长回文子序列 - 力扣（LeetCode）

  • dp数组及下标含义

dp[i][j]表示下标i - j部分含有的回文子序列的最大长度

  • 递推公式

如果s[i] == s[j]，

如果j < i + 2，dp[i][j] = j - i + 1

反之，dp[i][j] = dp[i + 1][j - 1] + 2

反之，看左右两边哪个的最长回文子序列更长，dp[i][j] = max(dp[i + 1][j], dp[i][j - 1])

  • 初始化

无需初始化

  • 遍历顺序

i从大到小，j从小到大，j大于等于i

int longestPalindromeSubseq(string s) {
    vector<vector<int>> dp(s.length(), vector<int>(s.length()));
    for(int i = s.length(); i >= 0; i--){
        for(int j = i; j < s.length(); j++){
            if(s[i] == s[j]){
                if(j < i + 2)
                    dp[i][j] = j - i + 1;
                else
                    dp[i][j] = dp[i + 1][j - 1] + 2;
            }
            else
                dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
        }
    }
    return dp[0][s.length() - 1];
}
最长递减子序列问题
shiter编写程序的艺术
10-08 1171
最长递减子序列的求解，可能在目标检测，工程计数等实际场景中使用，我们一块来看看怎么做
基于Java+动态规划算法解决最长公共子序列问题.zip
05-10
最长公共子序列（Longest Common Subsequence，LCS）问题是一个经典的计算机科学问题，主要涉及字符串处理和算法设计。在两个或多个字符串中找到一个最长的子序列，这个子序列不必连续，但必须保持原顺序。例如，...
灰色关联分析（系统分析+综合评价）
m0_62504956的博客
12-25 2784
将上面求出的关联系数每列指标求均值。
DP：子序列问题
2301_79969994的博客
07-02 2365
在计算机科学和数学中，子序列（Subsequence）是指从一个序列中删除一些元素（可以是零个或多个），但不改变其余元素相对顺序后形成的新序列。子序列的特点元素的相对顺序保持不变。可以删除零个或多个元素。一个序列的子序列可以为空序列，即不包含任何元素。举例说明设有序列 S = [A, B, C, D, E]，则其子序列可以有：删除零个元素：[A, B, C, D, E]（即自身）
最长公共子序列问题 c语言,最长公共子序列问题C语言
weixin_29063035的博客
05-22 1308
最长公共子序列问题C语言#include#include#includeint num[50][50]={0};int b[50][50]={0};int lcsLength(char *x,char *y,int xLen,int yLen);void LCS(int i,int j,char *x);int lcsLength(char *x,char *y,int xLen,int yLen...
代码随想录打卡第37天：动态规划解决子序列问题2
mooc666quq的博客
05-22 2100
打卡第37天：动态规划解决子序列问题2
子序列问题
ningmengccccc的博客
12-06 247
最近做了两道子序列问题，分别是 53、最大子序列和和152、乘积最大子序列 他们解决的办法大致相同，都是经过一次遍历保存一个遍历到当前数字的最大值，然后保留一个当前增益或但当前成绩，于是放到一起做一个总结。 53、最大子序列和（来自leetcode题解） 动态规划的是首先对数组进行遍历，当前最大连续子序列和为 sum，结果为 ans 如果 sum > 0，则说明 sum 对结果有增益...
最长公共子序列问题.docx
06-14
总的来说，通过动态规划法，我们可以有效地解决最长公共子序列问题，找到两个字符序列的最长共同部分，这在生物信息学、文本比较、数据压缩等领域有着广泛的应用。在实践中，理解并熟练掌握动态规划的思想和步骤，...
leetcode541-反转字符串II
weixin_45799371的博客
01-22 365
leetcode 541 反转字符串II
前k个高频元素力扣--347
2301_80113113的博客
01-22 396
给你一个整数数组nums和一个整数k，请你返回其中出现频率前k高的元素。你可以按返回答案。[1,2][1]k。
leetcode 740. 删除并获得点数
qq_62172019的博客
01-20 267
leetcode 740. 删除并获得点数。
LeetCode 62. 不同路径
makeke123456的博客
01-21 356
通过动态规划，我们可以有效地计算出机器人在网格中从左上角到右下角的不同路径数量。这种方法利用了状态转移方程和边界条件，避免了重复计算，提高了算法的效率。
刷题记录 LeetCode HOT 100 双指针-1 移动零
weixin_44610684的博客
01-22 244
难度：简单给定一个数组nums，编写一个函数将所有0移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。
leetcode-分割等和子集
最新发布
weixin_74047328的博客
01-23 464
一文看懂背包问题-分割等和子集
【力扣】2.两数相加
Father_Of_Soft的博客
01-22 259
力扣第二题，两数相加 c++解法
leetcode136.只出现一次的数字
m0_64995001的博客
01-21 367
除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。你必须设计并实现线性时间复杂度的算法来解决此问题，且该算法只使用常量额外空间。,也采用了计数排序思想。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值