力扣动态规划专题（五）子序列问题 不连续子序列与连续子序列 步骤及C++实现

已于 2023-06-25 20:21:56 修改
阅读量1.1k 收藏 2
点赞数 1
分类专栏： C++刷题-LeetCode-牛客 文章标签： 动态规划 leetcode c++
于 2023-06-24 16:14:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/UUUUU22/article/details/131317014
版权

文章目录


300.最长递增子序列

在这里插入图片描述

步骤

  1. 确定dp数组以及下标的含义
    dp[i]：i之前（包括i）以nums[i]结尾的最长递增子序列的长度。递增比较时，肯定要比较两个递增子序列的末尾元素，即递增子序列肯定是以末尾元素结尾的，否则比较没有意义

  2. 确定递推公式
    位置i 的最长升序子序列等于 = 位置j 的最长升序子序列 + 1 的最大值，j在[0, i-1]区间。假设dp[i]就是最长的升序子序列，那么dp[j]就是0~i-1的最长升序子序列再+1，即dp[i] = dp[j] + 1，为了取dp[j] + 1的最大值，if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);
    这里不是要dp[i] 与 dp[j] + 1进行比较，而是要取dp[j] + 1的最大值。

  3. dp数组如何初始化
    每一个i，对应的最长递增子序列dp[i]起始大小至少都是1

  4. 确定遍历顺序
    dp[i] 是由0到i-1各个位置的最长递增子序列推导而来，那么遍历i一定是从前向后遍历。并且j在[0, i-1]区间，那么j既可以从前到后，也可以从后到前遍历。遍历i在外循环，遍历j在内循环

  5. 举例推导dp数组
    输入：[0,1,0,3,2]

  6. C++实现

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

674.最长连续递增子序列

在这里插入图片描述

动态规划

步骤

相比于300.最长递增子序列最大的区别在于连续，要求的是最长连续递增序列，体现在递推公式

  1. 确定dp数组以及下标的含义
    dp[i]：以下标i为结尾的连续递增的子序列长度

  2. 确定递推公式
    如果 nums[i] > nums[i - 1]，那么以 i 为结尾的连续递增的子序列长度 = 以i - 1为结尾的连续递增的子序列长度 + 1 ，dp[i] = dp[i - 1] + 1;
    300题中比较的是nums[i]和nums[j]，而j是在[0, i-1]区间的，需要两层for循环。本题则是比较nums[i]和nums[i-1]，只需要一层for循环

  3. dp数组如何初始化
    以下标i为结尾的连续递增的子序列长度最少也应该是1

  4. 确定遍历顺序
    dp[i]依赖dp[i - 1]，从前向后遍历

  5. 举例推导dp数组
    输入nums = [1,3,5,4,7]

    dp[i]的最大值才是最终结果

  6. C++实现

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

贪心算法

只统计连续的递增序列长度，遇到nums[i] > nums[i-1]就记一次数

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        //贪心算法
        if(nums.size() == 0) return 0;
        int result = 1;
        int count = 1;
        for(int i=1; i<nums.size(); i++)
        {
            if(nums[i] > nums[i-1]) count++;
            else count = 1;
            if(count >result) result = count;
        }
        return result;
    }
};

718. 最长重复子数组

在这里插入图片描述
明确一点，子数组指的是连续子序列。

二维dp数组

步骤

  1. 确定dp数组以及下标的含义
    dp[i][j] ：以下标i - 1为结尾的nums1，和以下标j - 1为结尾的nums2，最长重复子数组长度

  2. 确定递推公式
    dp[i][j]的状态只能由dp[i - 1][j - 1]推导出来，当nums1[i - 1] 和nums2[j - 1]相等时，dp[i][j] = dp[i - 1][j - 1] + 1;，因此遍历i 和 j 都要从1开始

  3. dp数组如何初始化
    虽然dp[i][0] 和dp[0][j]没有意义，但是为了后续递推，dp[i][0] 和dp[0][j]都要初始化为0。例如，如果nums1[0]=nums2[0]，那么dp[1][1] = dp[0][0] + 1，只有dp[0][0]初始为0，才能计算dp[1][1]，并且符合递推公式。

  4. 确定遍历顺序
    遍历nums1和nums2的先后没有要求，题目要求长度最长的子数组的长度，遍历时要记录dp[i][j]的最大值

  5. C++实现

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        vector<vector<int>> dp(nums1.size()+1, vector<int>(nums2.size()+1, 0));
        int result = 0;
        for(int i=1; i<=nums1.size(); i++)
        {
            for(int j=1; j<=nums2.size(); j++)
            {
                if(nums1[i-1] == nums2[j-1]) dp[i][j] = dp[i-1][j-1] + 1;
                if(dp[i][j] > result) result = dp[i][j];
            }
        }
        return result;
    }
};

一维dp数组

二维dp数组中，dp[i][j]都是由dp[i - 1][j - 1]推出的，那么dp[i][j]压缩为一维数组dp[j]，也就是dp[j]都是由dp[j - 1]推出的。相当于可以把上一层dp[i - 1][j]拷贝到下一层dp[i][j]来继续用，此时遍历B数组的时候，就要从后向前遍历，这样避免重复覆盖。

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        //一维dp数组
        vector<int> dp(nums2.size()+1, 0);
        int result = 0;
        for(int i=1; i<=nums1.size(); i++)
        {
            for(int j=nums2.size(); j>0; j--)
            {
                if(nums1[i-1] == nums2[j-1]) dp[j] = dp[j-1] + 1;
                else dp[j] = 0; // 注意这里不相等的时候要有赋0的操作
                if(dp[j] > result) result = dp[j];
            }
        }
        return result;
    }
};

1143.最长公共子序列

在这里插入图片描述
和718题的区别在于不要求连续，但要有相对顺序，例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。

步骤

  1. 确定dp数组以及下标的含义
    dp[i][j]：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列的长度
    定义为长度为[0, i]的字符串text1也可以，但是实现比较复杂，需要初始化

  2. 确定递推公式

  • text1[i - 1] 与 text2[j - 1]相同，找到一个公共元素，dp[i][j] = dp[i - 1][j - 1] + 1;
  • text1[i - 1] 与 text2[j - 1]不相同，就看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的， dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);

  1. dp数组如何初始化
    test1[0, i-1]和空串的最长公共子序列是0，dp[i][0] = 0;，同理dp[0][j]=0。

  2. 确定遍历顺序
    从递推公式来看，有三个方向可以推出dp[i][j]，所以要从前向后，从上到下来遍历

  3. 举例推导dp数组
    输入：text1 = “abcde”, text2 = “ace” ，最后红框dp[text1.size()][text2.size()]为最终结果

  4. C++实现

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        vector<vector<int>> dp(text1.size()+1, vector<int>(text2.size()+1, 0));
        //从上到下 从前到后遍历
        for(int i=1; i<=text1.size(); i++)
        {
            for(int j=1; j<=text2.size(); j++)
            {
                if(text1[i-1] == text2[j-1]) dp[i][j] = dp[i-1][j-1] + 1;
                else dp[i][j] = max(dp[i][j-1], dp[i-1][j]);
            }
        }
        return dp[text1.size()][text2.size()];
    }
};

1035.不相交的线

在这里插入图片描述

分析

绘制一些连接两个数字nums1[i] 和nums2[j] 的直线，只要nums1[i] == nums2[j]，且直线不能相交。要保证直线不相交，就不能改变数字在原始序列的位置。
换句话说，题目要求的是nums1和nums2的最长公共子序列的长度，这个公共子序列的相对顺序不能改变，也就是题1143。

步骤

  1. 确定dp数组以及下标的含义
    dp[i][j]：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列的长度
    定义为长度为[0, i]的字符串text1也可以，但是实现比较复杂，需要初始化

  2. 确定递推公式

  • text1[i - 1] 与 text2[j - 1]相同，找到一个公共元素，dp[i][j] = dp[i - 1][j - 1] + 1;
  • text1[i - 1] 与 text2[j - 1]不相同，就看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的， dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);

  1. dp数组如何初始化
    test1[0, i-1]和空串的最长公共子序列是0，dp[i][0] = 0;，同理dp[0][j]=0。

  2. 确定遍历顺序
    从递推公式来看，有三个方向可以推出dp[i][j]，所以要从前向后，从上到下来遍历

  3. C++实现

class Solution {
public:
    int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2) {
        vector<vector<int>> dp(nums1.size()+1, vector<int>(nums2.size()+1, 0));
        for(int i=1; i<=nums1.size(); i++)
        {
            for(int j=1; j<=nums2.size(); j++)
            {
                if(nums1[i-1] == nums2[j-1]) dp[i][j] = dp[i-1][j-1] + 1;
                else dp[i][j] = max(dp[i][j-1], dp[i-1][j]);
            }
        }
        return dp[nums1.size()][nums2.size()];
    }
};

53. 最大子序和

在这里插入图片描述

动态规划

步骤

  1. 确定dp数组以及下标的含义
    dp[i]：包括下标i（以nums[i]为结尾）的最大连续子序列和

  2. 确定递推公式
    dp[i]只有两个方向可以推出来

  • nums[i]加入当前连续子序列和，dp[i - 1] + nums[i]
  • 从头开始计算当前连续子序列和，nums[i]
    取最大的，dp[i] = max(dp[i - 1] + nums[i], nums[i]);

  1. dp数组如何初始化
    dp[i]依赖于dp[i - 1]的状态，dp[0]是递推公式的基础。根据dp[i]的定义，dp[0] = nums[0]

  2. 确定遍历顺序
    dp[i]依赖dp[i - 1]，从前向后遍历

  3. 举例推导dp数组
    输入：nums = [-2,1,-3,4,-1,2,1,-5,4]，最后的结果不是dp[nums.size() - 1]，而是dp[6]，和最大的连续子序列。在递推时，可以直接选出最大的dp[i]最为最终结果。

  4. C++实现

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        vector<int> dp(nums.size(), 0);
        dp[0] = nums[0];//初始化 从位置1开始遍历
        int result = dp[0];
        for(int i=1; i<nums.size(); i++)
        {
            //dp[i-1]~nums[i]的最长连续子序列  从nums[0]~nums[i]的最长连续子序列
            //去两者最大值
            dp[i] = max(dp[i-1]+nums[i], nums[i]);
            if(dp[i] > result) result = dp[i];//筛选出结果
        }
        return result;
    }
};

贪心算法

局部最优的情况下，并记录最大的“连续和”，可以推出全局最优。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        //贪心算法
        int result = INT32_MIN;//记录最终累计和 全局解
        int count = 0;//记录当前累计和 局部最优解
        for(int i=1; i<=nums.size(); i++)
        {
            count += nums[i];//累计求和
            if(count > result) result = count;
            if(count <= 0) count = 0;//当前累计和小0
        }
        return result;
    }
};
虚假自律就会真自律！
关注
专栏目录
(连续子序列)唯一的雪花
及时总结
07-31 973
输入一个长度为n(n&amp;amp;lt;=1e6)的序列A，找到一个尽量长的连续子序列AL~AR,使得该序列中没有相同元素。输出最大长度。 对于这种子序列问题我们采用模拟的方法 方法一：利用set 1.如果有一个序列的元素没出现过，就把元素存到set里， 2.如果出现过，说明a[r+1]在子序列a[l]——a[r]出现过，那此时就不断地删去l，直到r增大到n 3.注意保存并更新最大序列个数 4.s...
leetcode:1143. 最长公共子序列
uncle_ll的博客
08-21 189
一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。的公共子序列，二维数组，从下标1开始，每个元素不断的与另外一个字符串挨个进行比较，如果匹配上了+1；例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。
最长连续递增子序列
qq_42090769的博客
12-11 677
给定一个顺序存储的线性表，请设计一个算法查找该线性表中最长的连续递增子序列。例如，(1,9,2,5,7,3,4,6,8,0)中最长的递增子序列为(3,4,6,8)。 输入格式: 输入第1行给出正整数n（≤10^5​）；第2行给出n个整数，其间以空格分隔。 输出格式: 在一行中输出第一次出现的最长连续递增子序列，数字之间用空格分隔，序列结尾不能有多余空格。 输入样例： 15 1 9 2 5 7 3 ...
7-42 实验7_7_连续子序列 (100 分)
weixin_62495164的博客
12-03 1686
已知两个由正整数组成的无序序列A、B，每个序列的元素个数未知，但至少有一个元素。你的任务是判断序列B是否是序列A的连续子序列。假设B是“1 9 2 4 18”，A是“33 64 1 9 2 4 18 7”，B是A的连续子序列；假设B是“1 9 2 4 18”，A是“33 1 9 64 2 4 18 7”，B不是A的连续子序列。 输入格式: 依次输入两个乱序的正整数序列A、B，序列中元素个数未知，但每个序列至少有一个元素，并以输入“-1”结束（-1不算序列中元素），每个序列占一行。两个数列的长度均不超过1
不连续子数组和
cxllyg的专栏
05-16 1247
借鉴《编程之美》书上的思想，利用动态规划，只需要O(N)的复杂度 假设从原数组a第i位开始的最大不连续子数组和为m[ i ]，有m[ i ] = max(a[ i ] + m[ i+2 ], m[ i+1 ])。 #include using namespace std; int max(int x, int y) { return (x>y)?x:y; } i
连续最大子序列和
weixin_30797027的博客
05-27 108
#include <iostream> using namespace std; int subsequence( int A[], int N); int main() { int a[100], n; cin>>n; for(int i = 0; i < n; i++) cin>>a[i]; ...
二叉树的序列化和反序列化——C++
净无邪博客
12-15 2577
总体解题思想为先用层次遍历存储包括空节点的每个节点，存储是每个节点都存储左右子节点，如果节点为空，则存储"#,"，否则存储节点的值val，同时用逗号','分割每个节点内容，存储完后进行序列化string。反序列化则先按逗号','分割每个字符串为数组字符串vector<string> valStrArr，该valStrArr存储每个节点的值，包括空节点；然后遍历valStrArr，反向构建原始二叉树。反向构建二叉树时由于存储是按层次遍历存入的，所以反向遍历时也需要按照层次遍历依次将非空节点压栈和弹出栈。由于层
【笔记】动态规划总结 2.0
ericma12的博客
03-21 672
时隔大半年，二刷代码随想录，发现有的dp定义不好想，有的dp转移方程还是看不懂......
力扣500题刷题笔记6
08-04
在力扣（LeetCode）第500题的刷题笔记中，主要涉及的是寻找数组中满足特定条件的最短连续子数组的问题。这个问题可以使用双指针技术来解决，具体是找到一个长度最小的连续子数组，其元素之和大于或等于给定的目标值`...
一键修复“一看就会，一学就废”bug——动态规划
05-12 2376
一看就会，一写就废，我太难了
动态规划实例--数组不连续取数问题（python 实现）
SZ-crystal
04-26 3555
问题： 给定一个长度为N的一维数组 举例：输入：[1,3,5,2,1,9,4,3,7] 取数规则：不允许取连续的两个数。 求：这个数组在给定规则下取到数字的最大和是？ 本例中，答案为：1+5+9+7=22 解题思路 新建一个与输入数组input_num大小相同的数组max_num 记max_num[i]为前i+1天的最大训练天数(因为数组第一项是m...
动态规划经典题目：最大连续子序列和、最大不连续子序列和
weixin_42067304的博客
03-13 2002
1.最大连续子序列和： 记数组为nums 思路：记录dp[i]为i位置结尾的最大连续子序列和 则有dp[i]=dp[i-1]>0?(dp[i-1]+nums[i]):nums[i]; 然后求dp数组的max即为最终结果 1.最大不连续子序列和： 记数组为nums 思路：记录dp[i]为i位置的最大不连续子序列和 则有两种情况dp[i]=dp[i-1] 或者dp[i]=dp[i-2]+nums[i] 即不选或者选择当前位置 那么整理为dp[i]=m...
算法学习笔记——动态规划：不连续取值的前提下求最大总和
Insomnia_X的博客
07-15 314
LeetCode 198. 打家劫舍 一排房屋，某房屋内的金额数为nums[i]，相邻房屋内的钱不能被同时取出，求最多能取出多少钱 nums=[1,1,3,4]，返回5（选择取出1+4=5） dp[i]代表对于0~i号房屋，能取走的最大金额 依次考虑每个房屋，显然每次只有两种选择: dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]) 若要取出当前房屋的钱，则不能拿取前一个房屋的钱 若不取出当前房屋的钱，则可以拿取前一个房屋的钱（当然，前一个房屋同样可以选择拿或不拿）.
连续子序列之和
云胡
05-23 583
1049 最大子段和 题目描述 N个整数组成的序列a[1],a[2],a[3],…,a[n]，求该序列如a[i]+a[i+1]+…+a[j]的连续子段和的最大值。当所给的整数均为负数时和为0。 例如：-2,11,-4,13,-5,-2，和最大的子段为：11,-4,13。和为20。 Input 第1行：整数序列的长度N（2<=N<=50000) 第2-N+1行...
Leetcode 刷题笔记(二十八) ——动态规划篇之子序列问题：连续子序列和不连续子序列
a1241692733的博客
03-15 3353
动态规划中，连续子序列和不连续子序列问题
动态规划——子序列问题——连续？不连续？
getinobacar的博客
03-03 5560
动态规划——子序列问题——连续？不连续？ 子序列问题是动态规划的一个常考题型，本篇文章主要介绍 子序列（连续）和子序列（不连续）两个问题。连续和不连续指的是子序列是否是连续的，还是说中间是可以有间隔的子序列。 一：子序列（不连续） 300. 最长递增子序列 分析：从题意我们可以读出该题想求的是不连续的递增子序列。 解法：动态规划 第一步：dp[i]的定义 dp[i]表示i之前包括i的最长上升子序列的长度。 第二步：状态转移方程 位置 i 的最长升序子序列等于 j 从 0..
单调连续递增子序列（O（n2）
KeepMovingOn的博客
04-02 669
思想：这道题时间复杂度为o(n2)，是LCS（最长公共子序列）的变形。相当于 一个x  原数组，一个y  数组由x  数组 升序排列并去掉重复值，求两个数组的最长公共子序列问题。
和最大的连续子序列
远方的橄榄树
10-26 903
2016京东校园招聘数字营销岗的笔试题问题描述： 一个一维数组同时包含有正整数和负整数，找到数组里和最大的连续子序列 如：给定数组{-2, -5, 6, -2, -3, 1, 5, -6}, 最大和是7，{6, -2, -3, 1, 1, 5}
C++求数组中最大子序列问题
qq_41614638的博客
05-26 395
在慕课上学习数据结构时看到的C++代码用来解决，借鉴的是浙大老师讲的数据结构，很推荐。 第一种是分治思想 int Max3(int A, int B, int C) { /* 返回3个整数中的最大值 */ return A > B ? A > C ? A : C : B > C ? B : C; } int DivideAndConquer(int List[], int left, int right) { /* 分治法求List[left]到List[right]的最大子列和 */
力扣最长连续序列c++
最新发布
08-15
在LeetCode（力扣）上，有一个经典的算法题目叫做“最长连续序列”（Longest Continuous Increasing Subsequence），通常用C++或其他编程语言进行解答。这个题目的目的是找到一个给定整数数组中的最长递增子序列。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值