动态规划解决子序列系列问题——代码随想录

动态规划经常用来处理连续子序列的问题
1.最长递增序列
最长递增序列
（1）题目分析
找到最长严格递增子序列的长度，这里并没有要求连续，只是提到了相对位置关系。
动态规划五部曲分析
a.dp[i]的定义
dp[i]表示i之前包括i的最长上升子序列的长度；
b.状态转移方程
if(nums[i]>nums[j]) dp[i] = max(dp[i],dp[j]+1);
c.dp[i]初始化
每一个i,对应的dp[i]最长上升子序列，起始大小至少是1；
d.确定遍历顺序
dp[i]是从0到i-1推导而来，那么一定是从前向后遍历。
e.举例验证
（2）代码实现

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        if(nums.size()<=1) return nums.size();
        vector<int> dp(nums.size(),1);//定义动态规划数组，数组的含义是前i个元素中最长递增子序列的长度,初始化为1，初始化为0的时候会影响后续的序列长度比较
        int result = 0; //记录当前动态数组的最大值
        for(int i=1;i<nums.size();i++){//递归方向为从前往后，下面每一次小循环中dp[i]的值是会迭代更新的
            for(int j=0;j<i;j++){//元素比较的范围是前i个元素
                if(nums[i]>nums[j]){
                    dp[i] = max(dp[j]+1,dp[i]);
                }
            }
            if(dp[i]>result) result = dp[i];//result记录最大值的方法用在那些不应数组末尾是最大值的情况
        }
        return result;
    }
};

2.最长连续递增序列
最长连续递增序列
（1）题目分析
找到最长连续递增递增子序列的长度
动态规划五部曲分析
a.dp[i]的定义
dp[i]表示i之前包括i的最长连续上升子序列的长度；
b.状态转移方程
因为要求子序列是连续的，所以元素大小的比较对象就变成了相邻两个元素之间的比较，
相邻元素关系的大小比较用一层循环就可以比较。
if(nums[i]>nums[j]) dp[i] = max(dp[i],dp[j]+1);
c.dp[i]初始化
每一个i,对应的dp[i]最长上升子序列，起始大小至少是1；
d.确定遍历顺序
dp[i]是从0到i-1推导而来，那么一定是从前向后遍历。
e.举例验证
可以看出自己操作元素的范围和操作对象是否正确。

（2）代码实现

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        if(nums.size()<=1) return nums.size();
        vector<int> dp(nums.size(),1);
        int result = 0; 
        for(int i=0;i<nums.size()-1;i++){
            if(nums[i+1]>nums[i]){
                dp[i+1] = dp[i]+1;//注意这里迭代更细的dp数组对应的元素值是dp[i+1]而不是dp[i]
            }
            if(result<dp[i+1]){
                result = dp[i+1];
            }
        }
        return result;
    }
};

3.最长重复子数组
最长重复子数组
（1）题目分析
已知两个整数子数组，返回两个数组中公共的最长的子数组的长度。
动态规划五部曲分析
a.dp[i][j]的定义
dp[i][j]表示以A数组前i个元素 中和B数组前j-1个元素中，最长重复子数组长度为dp[i][j]
b.状态转移方程

//在A[i-1]和B[j-1]相等的条件下
dp[i][j] = dp[i - 1][j - 1] + 1;

c.dp[i][j]初始化
当一个数组长度为0这种比较没有意义，边界值的问题
dp[i][0] 和dp[0][j]都没有意义
d.确定遍历顺序
对A B建立两层循环
e.举例验证
可以看出自己操作元素的范围和操作对象是否正确。
（2）代码实现

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        if(nums1.size()==0||nums2.size()==0) return 0;
        //vector定义二维数组
        vector<vector<int>>dp(nums1.size()+1,vector<int>(nums2.size()+1));//这里定义长度要＋1比较合适
        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;
    }
};

4.最长公共子序列
最长公共子序列
相同的题目：不相交的线
相同元素线不相交也是对相对位置的要求。
（1）题目分析
已知两个整数子数组，返回两个数组中公共的最长的公共子序列，不要求连续，但要求有相对位置。
动态规划五部曲分析
a.dp[i][j]的定义
dp[i][j]表示以A字符串前i个元素 中和B字符串前j-1个元素中，最长重复子数组长度为dp[i][j]
b.状态转移方程

//在A[i-1]和B[j-1]相等的条件下
dp[i][j] = dp[i - 1][j - 1] + 1;
//在A[i-1]和B[j-1]不相等的条件下
dp[i][j] = max（dp[i-1][j],dp[i][j-1]）;

c.dp[i][j]初始化
当一个数组长度为0这种比较没有意义，边界值的问题
dp[i][0] 和dp[0][j]都是0；
其他随着递推公式逐步覆盖
d.确定遍历顺序，从上往下，从前往后
对A B建立两层循环
e.举例验证
可以看出自己操作元素的范围和操作对象是否正确。
（2）代码实现

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        //对输入字符串的判断
        if(text1.size()==0||text2.size()==0) return 0;
        //vector定义二维数组,之前用char就会出错，还是没有想清楚原因
        vector<vector<int>> dp(text1.size()+1,vector<int>(text2.size()+1,0));
        int result = 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-1][j],dp[i][j-1]);
                }
                if(result<dp[i][j]) result = dp[i][j];
            } 
        }
        return result;
    }
};

5.最大子序和
最大子序和
（1）题目分析
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
动态规划五部曲分析
a.dp[i]的定义
包括下标i之前的最大连续子序列的和为dp[i]
b.状态转移方程
dp[i]只有两个方向可以推导出来
加入遍历此时的新元素；
从头开始计算；
dp[i] = max(dp[i - 1] + nums[i], nums[i]);
c.dp[i]初始化
dp[0] = nums[0];编程实现时，将记录的result值习惯性的写成了int result = 0；导致出错
d.确定遍历顺序
从前往后遍历
（暂时还没有遇到逆向遍历）

e.举例验证
可以看出自己操作元素的范围和操作对象是否正确。
（2）代码实现

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        //对输入数组进行判断，只有一个元素的数组不算是特殊情况
        if(nums.size()==0) return 0 ;
        //定义动态规划数组，表示数组中前i个元素和的最大值
        vector<int> dp(nums.size(),0);
        dp[0] = nums[0];//初始化数组
        int result = dp[0];//记录数组中的最大值,不要习惯性的写成了int result =0;
        for(int i = 1;i<nums.size();i++){
            //更新数值的公式
            dp[i] = max(dp[i-1]+nums[i],nums[i]);
            if(dp[i]>result) result = dp[i];
        }
        return result;
    }
};